first commit

node_modules/expo-font/plugin/build/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function toValidAndroidResourceName(value: string): string;
+export declare function resolveFontPaths(fonts: string[], projectRoot: string): Promise<string[]>;

node_modules/expo-font/plugin/build/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toValidAndroidResourceName = toValidAndroidResourceName;
+exports.resolveFontPaths = resolveFontPaths;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+// rule: File-based resource names must contain only lowercase a-z, 0-9, or underscore
+function toValidAndroidResourceName(value) {
+    const valueWithoutFileExtension = path_1.default.parse(value).name;
+    const withUnderscores = valueWithoutFileExtension
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2');
+    return withUnderscores
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '_')
+        .replace(/_+/g, '_');
+}
+async function resolveFontPaths(fonts, projectRoot) {
+    const promises = fonts.map(async (p) => {
+        const resolvedPath = path_1.default.resolve(projectRoot, p);
+        const stat = await promises_1.default.stat(resolvedPath);
+        if (stat.isDirectory()) {
+            const dir = await promises_1.default.readdir(resolvedPath);
+            return dir.map((file) => path_1.default.join(resolvedPath, file));
+        }
+        return [resolvedPath];
+    });
+    return (await Promise.all(promises))
+        .flat()
+        .filter((p) => p.endsWith('.ttf') || p.endsWith('.otf') || p.endsWith('.woff') || p.endsWith('.woff2'));
+}

node_modules/expo-font/plugin/build/withFonts.d.ts

@@ -0,0 +1,21 @@
+import { type ConfigPlugin } from 'expo/config-plugins';
+export type FontObject = {
+    fontFamily: string;
+    fontDefinitions: {
+        path: string;
+        weight: number;
+        style?: 'normal' | 'italic' | undefined;
+    }[];
+};
+export type Font = string | FontObject;
+export type FontProps = {
+    fonts?: string[];
+    android?: {
+        fonts?: Font[];
+    };
+    ios?: {
+        fonts?: string[];
+    };
+};
+declare const _default: ConfigPlugin<FontProps>;
+export default _default;

node_modules/expo-font/plugin/build/withFonts.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("expo/config-plugins");
+const withFontsAndroid_1 = require("./withFontsAndroid");
+const withFontsIos_1 = require("./withFontsIos");
+const pkg = require('expo-font/package.json');
+const withFonts = (config, props) => {
+    if (!props) {
+        return config;
+    }
+    const iosFonts = [...(props.fonts ?? []), ...(props.ios?.fonts ?? [])];
+    if (iosFonts.length > 0) {
+        config = (0, withFontsIos_1.withFontsIos)(config, iosFonts);
+    }
+    const androidFonts = [...(props.fonts ?? []), ...(props.android?.fonts ?? [])];
+    if (androidFonts.length > 0) {
+        config = (0, withFontsAndroid_1.withFontsAndroid)(config, androidFonts);
+    }
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withFonts, pkg.name, pkg.version);

node_modules/expo-font/plugin/build/withFontsAndroid.d.ts

@@ -0,0 +1,24 @@
+import { type ConfigPlugin } from 'expo/config-plugins';
+import type { Font, FontObject } from './withFonts';
+export declare const withFontsAndroid: ConfigPlugin<Font[]>;
+type GroupedFontObject = Record<string, FontObject['fontDefinitions']>;
+export declare function groupByFamily(array: FontObject[]): GroupedFontObject;
+export declare function getXmlSpecs(fontsDir: string, xmlFontObjects: GroupedFontObject): {
+    path: string;
+    xml: {
+        'font-family': {
+            $: {
+                'xmlns:app': string;
+            };
+            font: {
+                $: {
+                    'app:font': string;
+                    'app:fontStyle': "normal" | "italic";
+                    'app:fontWeight': string;
+                };
+            }[];
+        };
+    };
+}[];
+export declare function generateFontManagerCalls(xmlFontObjects: GroupedFontObject, language: 'java' | 'kt'): string[];
+export {};

node_modules/expo-font/plugin/build/withFontsAndroid.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFontsAndroid = void 0;
+exports.groupByFamily = groupByFamily;
+exports.getXmlSpecs = getXmlSpecs;
+exports.generateFontManagerCalls = generateFontManagerCalls;
+const config_plugins_1 = require("expo/config-plugins");
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const assetsFontsFir = 'app/src/main/assets/fonts';
+const resourcesFontsDir = 'app/src/main/res/font';
+const withFontsAndroid = (config, fonts) => {
+    const assetFontPaths = fonts.filter((it) => typeof it === 'string');
+    config = copyFontsToDir(config, assetFontPaths, assetsFontsFir);
+    const xmlFonts = fonts.filter((it) => typeof it === 'object');
+    config = addXmlFonts(config, xmlFonts);
+    return config;
+};
+exports.withFontsAndroid = withFontsAndroid;
+function groupByFamily(array) {
+    return array.reduce((result, item) => {
+        const keyValue = item['fontFamily'];
+        result[keyValue] ||= [];
+        result[keyValue].push(...item.fontDefinitions);
+        return result;
+    }, {});
+}
+function addXmlFonts(config, xmlFontObjects) {
+    const fontsByFamily = groupByFamily(xmlFontObjects);
+    const fontPaths = Object.values(fontsByFamily)
+        .map((font) => font.map((it) => it.path))
+        .flat();
+    config = copyFontsToDir(config, fontPaths, resourcesFontsDir, (filenameWithExt) => {
+        const filename = (0, utils_1.toValidAndroidResourceName)(filenameWithExt);
+        const ext = path_1.default.extname(filenameWithExt);
+        return `${filename}${ext}`;
+    });
+    config = addFontXmlToMainApplication(config, fontsByFamily);
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        async (config) => {
+            const fontsDir = path_1.default.join(config.modRequest.platformProjectRoot, 'app/src/main/res/font');
+            const xmlSpecs = getXmlSpecs(fontsDir, fontsByFamily);
+            await Promise.all(xmlSpecs.map(config_plugins_1.XML.writeXMLAsync));
+            return config;
+        },
+    ]);
+}
+const resourceNameConflictAvoidancePrefix = 'xml_';
+function getXmlSpecs(fontsDir, xmlFontObjects) {
+    return Object.entries(xmlFontObjects).map(([fontFamily, fontDefinitions]) => {
+        const filePath = path_1.default.join(fontsDir, `${resourceNameConflictAvoidancePrefix + (0, utils_1.toValidAndroidResourceName)(fontFamily)}.xml`);
+        // each font family has one xml resource file with potentially multiple font definitions
+        // the font files (e.g. ttf) at `path` are copied to res/font
+        // with their name changed to be a valid resource and referenced in the xml file
+        return {
+            path: filePath,
+            xml: {
+                'font-family': {
+                    // using `app` namespace for better compat:
+                    // https://developer.android.com/develop/ui/views/text-and-emoji/fonts-in-xml#using-support-lib
+                    $: {
+                        'xmlns:app': 'http://schemas.android.com/apk/res-auto',
+                    },
+                    font: fontDefinitions.map((definition) => {
+                        return {
+                            $: {
+                                'app:font': `@font/${(0, utils_1.toValidAndroidResourceName)(definition.path)}`,
+                                'app:fontStyle': definition.style || 'normal',
+                                'app:fontWeight': String(definition.weight),
+                            },
+                        };
+                    }),
+                },
+            },
+        };
+    });
+}
+function addFontXmlToMainApplication(config, xmlFontObjects) {
+    return (0, config_plugins_1.withMainApplication)(config, (config) => {
+        const { modResults, modResults: { language }, } = config;
+        modResults.contents = config_plugins_1.AndroidConfig.CodeMod.addImports(modResults.contents, ['com.facebook.react.common.assets.ReactFontManager'], language === 'java');
+        const fontManagerCalls = generateFontManagerCalls(xmlFontObjects, language).join(os_1.default.EOL);
+        const withInit = config_plugins_1.CodeGenerator.mergeContents({
+            src: modResults.contents,
+            comment: '    //',
+            tag: 'xml-fonts-init',
+            offset: 1,
+            anchor: /super\.onCreate\(\)/,
+            newSrc: fontManagerCalls,
+        });
+        return {
+            ...config,
+            modResults: {
+                ...modResults,
+                contents: withInit.contents,
+            },
+        };
+    });
+}
+function generateFontManagerCalls(xmlFontObjects, language) {
+    const lineEnding = language === 'java' ? ';' : '';
+    const indent = '    ';
+    return Object.keys(xmlFontObjects).map((family) => `${indent}ReactFontManager.getInstance().addCustomFont(this, "${family}", R.font.${resourceNameConflictAvoidancePrefix + (0, utils_1.toValidAndroidResourceName)(family)})${lineEnding}`);
+}
+function copyFontsToDir(config, paths, inAppDestination, filenameProcessor = (filenameWithExt) => filenameWithExt) {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        'android',
+        async (config) => {
+            const fontsDir = path_1.default.join(config.modRequest.platformProjectRoot, inAppDestination);
+            await promises_1.default.mkdir(fontsDir, { recursive: true });
+            const resolvedFonts = await (0, utils_1.resolveFontPaths)(paths, config.modRequest.projectRoot);
+            await Promise.all(resolvedFonts.map(async (asset) => {
+                const filenameWithExt = path_1.default.basename(asset);
+                const outputFileName = filenameProcessor(filenameWithExt);
+                const output = path_1.default.join(fontsDir, outputFileName);
+                if (output.endsWith('.ttf') || output.endsWith('.otf')) {
+                    await promises_1.default.copyFile(asset, output);
+                }
+            }));
+            return config;
+        },
+    ]);
+}

node_modules/expo-font/plugin/build/withFontsIos.d.ts

@@ -0,0 +1,2 @@
+import { type ConfigPlugin } from 'expo/config-plugins';
+export declare const withFontsIos: ConfigPlugin<string[]>;

node_modules/expo-font/plugin/build/withFontsIos.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFontsIos = void 0;
+const config_plugins_1 = require("expo/config-plugins");
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const withFontsIos = (config, fonts) => {
+    config = addFontsToTarget(config, fonts);
+    config = addFontsToPlist(config, fonts);
+    return config;
+};
+exports.withFontsIos = withFontsIos;
+function addFontsToTarget(config, fonts) {
+    return (0, config_plugins_1.withXcodeProject)(config, async (config) => {
+        const resolvedFonts = await (0, utils_1.resolveFontPaths)(fonts, config.modRequest.projectRoot);
+        const project = config.modResults;
+        const platformProjectRoot = config.modRequest.platformProjectRoot;
+        config_plugins_1.IOSConfig.XcodeUtils.ensureGroupRecursively(project, 'Resources');
+        addResourceFile(project, platformProjectRoot, resolvedFonts);
+        return config;
+    });
+}
+function addFontsToPlist(config, fonts) {
+    return (0, config_plugins_1.withInfoPlist)(config, async (config) => {
+        const resolvedFonts = await (0, utils_1.resolveFontPaths)(fonts, config.modRequest.projectRoot);
+        const existingFonts = getUIAppFonts(config.modResults);
+        const fontList = resolvedFonts.map((font) => path_1.default.basename(font)) ?? [];
+        const allFonts = [...existingFonts, ...fontList];
+        config.modResults.UIAppFonts = Array.from(new Set(allFonts));
+        return config;
+    });
+}
+function addResourceFile(project, platformRoot, f) {
+    for (const font of f) {
+        const fontPath = path_1.default.relative(platformRoot, font);
+        config_plugins_1.IOSConfig.XcodeUtils.addResourceFileToGroup({
+            filepath: fontPath,
+            groupName: 'Resources',
+            project,
+            isBuildFile: true,
+            verbose: true,
+        });
+    }
+}
+function getUIAppFonts(infoPlist) {
+    const fonts = infoPlist['UIAppFonts'];
+    if (fonts != null && Array.isArray(fonts) && fonts.every((font) => typeof font === 'string')) {
+        return fonts;
+    }
+    return [];
+}