@vanenshi/expo-plugins 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amir Shekari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# @vanenshi/expo-plugins
+
+A small collection of [Expo config plugins](https://docs.expo.dev/config-plugins/introduction/).
+
+## Install
+
+```sh
+npx expo install @vanenshi/expo-plugins
+```
+
+---
+
+## `withDisplayName`
+
+**Goal:** Give each build variant (dev / beta / prod) its own home-screen
+display name on both iOS and Android — without touching the internal root `name`
+(which drives bundle structure and forces slow clean rebuilds when changed).
+
+**Underneath:**
+- **iOS** — sets `CFBundleDisplayName` in `Info.plist` via `withInfoPlist`.
+- **Android** — sets `app_name` in `strings.xml` via `withStringsXml`.
+
+```ts
+// app.config.ts
+export default {
+  name: "MyApp", // internal project name — unchanged
+  plugins: [
+    ["@vanenshi/expo-plugins/display-name", { displayName: "MyApp (Beta)" }],
+  ],
+};
+```
+
+### Options
+
+| Option        | Type     | Description                                        |
+| ------------- | -------- | -------------------------------------------------- |
+| `displayName` | `string` | Name shown to users on the home screen (required). |
+
+---
+
+## `withExpoGoogleFonts`
+
+**Goal:** Embed `@expo-google-fonts/*` faces into the native projects without
+manually listing every font path in your app config. The plugin reads the
+weight/style folder layout from your installed packages, resolves the `.ttf`
+file paths, and delegates to `expo-font` — so you only declare _which_ font
+families and weights you want.
+
+**Underneath:**
+- **Discovery** — walks `@expo-google-fonts/<name>` package folders, parses
+  folder names like `400Regular` / `700Bold_Italic`, and collects `.ttf` paths.
+- **Delegation** — passes the resolved font manifest to `expo-font/app.plugin`
+  (`withFonts`), which handles embedding into both Android assets and iOS
+  `Info.plist`.
+
+```sh
+npx expo install expo-font @expo-google-fonts/roboto @expo-google-fonts/inter
+```
+
+```json
+{
+  "plugins": [
+    [
+      "@vanenshi/expo-plugins/google-fonts",
+      {
+        "fonts": [
+          { "packageName": "roboto", "weights": [400, 500, 700], "importItalic": true },
+          { "packageName": "inter", "weights": [400, 600] }
+        ]
+      }
+    ]
+  ]
+}
+```
+
+No separate `["expo-font", ...]` entry is needed.
+
+> Need the raw `expo-font` options (e.g. to merge with local fonts)? Import
+> `buildExpoGoogleFontsOptions(input)` and pass the result to
+> `["expo-font", options]` yourself.
+
+### Options
+
+| Option          | Type               | Default         | Description                                            |
+| --------------- | ------------------ | --------------- | ------------------------------------------------------ |
+| `fonts`         | `GoogleFontSpec[]` | —               | Fonts to embed (see below).                            |
+| `projectRoot`   | `string`           | `process.cwd()` | Where to resolve `@expo-google-fonts/*` packages from. |
+| `warnOnMissing` | `boolean`          | `true`          | Warn when a package, weight, or `.ttf` is missing.     |
+
+`GoogleFontSpec`: `{ packageName, fontFamily?, weights?, importItalic? }` —
+`weights` defaults to `[400]`, `fontFamily` defaults to the package's metadata
+family name.
+
+---
+
+## Development
+
+This package uses [`expo-module-scripts`](https://github.com/expo/expo/tree/main/packages/expo-module-scripts) and follows [`expo/config-plugins`](https://github.com/expo/config-plugins) conventions.
+
+```sh
+pnpm install
+pnpm run build   # compile src/ → build/
+pnpm run lint
+pnpm test
+```
+
+### Example app
+
+`apps/app` is a minimal Expo app wiring both plugins, used to verify plugins
+work end-to-end via `expo prebuild`:
+
+```sh
+cd apps/app
+npm install
+npx expo prebuild --clean
+grep "Example (Beta)" android/app/src/main/res/values/strings.xml
+grep "CFBundleDisplayName" ios/*/Info.plist
+```
+
+See [`apps/app/README.md`](apps/app/README.md) for details.
+
+### Publishing
+
+CI publishes to npm on every **GitHub Release** ([`.github/workflows/publish.yml`](.github/workflows/publish.yml)).
+Add an `NPM_TOKEN` repo secret (npm Automation token), then:
+
+```sh
+pnpm version <patch|minor|major>
+git push --follow-tags
+# create a GitHub Release from the new tag — CI builds, tests, and publishes
+```
+
+---
+
+## Architecture decisions
+
+See [`docs/adr/`](docs/adr/) for the recorded decisions behind this package's design:
+package structure ([ADR-0001](docs/adr/0001-single-package.md)),
+toolchain ([ADR-0002](docs/adr/0002-expo-module-scripts.md)),
+logging ([ADR-0003](docs/adr/0003-warning-aggregator-logger.md)),
+font discovery ([ADR-0004](docs/adr/0004-google-fonts-auto-discovery.md)),
+folder-per-plugin layout ([ADR-0005](docs/adr/0005-folder-per-plugin-layout.md)),
+and cross-platform display name ([ADR-0006](docs/adr/0006-cross-platform-display-name.md)).

package/build/display-name/index.d.ts

@@ -0,0 +1,11 @@
+import { ConfigPlugin } from "expo/config-plugins";
+export interface DisplayNameProps {
+    /**
+     * Display name shown to users on the home screen. Applied to
+     * `CFBundleDisplayName` (iOS) and `app_name` in `strings.xml` (Android).
+     * When omitted the plugin is a no-op.
+     */
+    displayName?: string;
+}
+declare const _default: ConfigPlugin<void | DisplayNameProps>;
+export default _default;

package/build/display-name/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("expo/config-plugins");
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)("@vanenshi/expo-plugins/display-name");
+const pkg = require("../../package.json");
+/**
+ * Sets a custom display name on both iOS and Android without touching the root
+ * `name` (which drives bundle structure and internal module naming). Lets you
+ * give each build variant (dev, beta, prod) its own user-facing name while
+ * keeping internal naming consistent.
+ *
+ * Underneath:
+ * - iOS: sets `CFBundleDisplayName` in `Info.plist` via `withInfoPlist`.
+ * - Android: sets `app_name` in `strings.xml` via `withStringsXml`.
+ *
+ * @example
+ * // app.config.ts
+ * plugins: [["@vanenshi/expo-plugins/display-name", { displayName: "My App (Beta)" }]]
+ */
+const withDisplayName = (config, props) => {
+    const displayName = props?.displayName;
+    if (!displayName)
+        return config;
+    // Android
+    config = (0, config_plugins_1.withStringsXml)(config, (modConfig) => {
+        if (modConfig.name) {
+            logger.warnAndroid(`displayName is set — ignoring abstract "name": ${modConfig.name}`);
+        }
+        const strings = modConfig.modResults.resources.string ?? [];
+        const entry = strings.find((item) => item.$.name === "app_name");
+        if (entry) {
+            entry._ = displayName;
+        }
+        else {
+            strings.push({ $: { name: "app_name" }, _: displayName });
+            modConfig.modResults.resources.string = strings;
+        }
+        return modConfig;
+    });
+    // iOS
+    config = (0, config_plugins_1.withInfoPlist)(config, (modConfig) => {
+        if (modConfig.name) {
+            logger.warnIOS(`displayName is set — ignoring abstract "name": ${modConfig.name}`);
+        }
+        modConfig.modResults.CFBundleDisplayName = displayName;
+        return modConfig;
+    });
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withDisplayName, "@vanenshi/expo-plugins/display-name", pkg.version);

package/build/google-fonts/discovery.d.ts

@@ -0,0 +1,34 @@
+type FontStyle = "normal" | "italic";
+export interface FontFace {
+    path: string;
+    absPath: string;
+    weight: number;
+    style: FontStyle;
+}
+export interface DiscoveredPackage {
+    fontFamily: string;
+    faces: Map<string, FontFace>;
+}
+export declare const TTF_REQUIRE_RE: RegExp;
+export declare const FOLDER_TO_WEIGHT: Record<string, number>;
+export declare function parseFolder(folder: string): {
+    weight: number;
+    style: FontStyle;
+} | null;
+/**
+ * Parses an already-resolved `@expo-google-fonts/*` package directory.
+ * Pure: no `require.resolve`, no network. Suitable for unit testing with a
+ * committed fixture directory.
+ */
+export declare function parsePackage(pkgDir: string, packageName: string): DiscoveredPackage | null;
+/**
+ * Resolves the `@expo-google-fonts/<packageName>` package directory via
+ * `require.resolve`. This is the only side-effectful seam; keep it thin.
+ */
+export declare function resolvePackageDir(packageName: string, projectRoot: string): string | null;
+/**
+ * Discovers a Google Fonts package: resolves it then parses its contents.
+ * Emits a warning and returns null when the package is missing or malformed.
+ */
+export declare function discoverPackage(packageName: string, projectRoot: string, warnOnMissing: boolean): DiscoveredPackage | null;
+export {};

package/build/google-fonts/discovery.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOLDER_TO_WEIGHT = exports.TTF_REQUIRE_RE = void 0;
+exports.parseFolder = parseFolder;
+exports.parsePackage = parsePackage;
+exports.resolvePackageDir = resolvePackageDir;
+exports.discoverPackage = discoverPackage;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)("@vanenshi/expo-plugins/google-fonts");
+exports.TTF_REQUIRE_RE = /require\(['"]\.\/([^'"]+\.ttf)['"]\)/g;
+exports.FOLDER_TO_WEIGHT = {
+    "100Thin": 100,
+    "200ExtraLight": 200,
+    "300Light": 300,
+    "400Regular": 400,
+    "500Medium": 500,
+    "600SemiBold": 600,
+    "700Bold": 700,
+    "800ExtraBold": 800,
+    "900Black": 900,
+};
+function parseFolder(folder) {
+    const italic = folder.endsWith("_Italic");
+    const base = italic ? folder.slice(0, -"_Italic".length) : folder;
+    if (!(base in exports.FOLDER_TO_WEIGHT))
+        return null;
+    const weight = exports.FOLDER_TO_WEIGHT[base] ?? 400;
+    return { weight, style: italic ? "italic" : "normal" };
+}
+/**
+ * Parses an already-resolved `@expo-google-fonts/*` package directory.
+ * Pure: no `require.resolve`, no network. Suitable for unit testing with a
+ * committed fixture directory.
+ */
+function parsePackage(pkgDir, packageName) {
+    const metadataPath = node_path_1.default.join(pkgDir, "metadata.json");
+    const indexPath = node_path_1.default.join(pkgDir, "index.js");
+    if (!node_fs_1.default.existsSync(metadataPath) || !node_fs_1.default.existsSync(indexPath)) {
+        logger.warn(`@expo-google-fonts/${packageName} is missing metadata.json or index.js.`);
+        return null;
+    }
+    const { family } = JSON.parse(node_fs_1.default.readFileSync(metadataPath, "utf8"));
+    const faces = new Map();
+    for (const match of node_fs_1.default
+        .readFileSync(indexPath, "utf8")
+        .matchAll(exports.TTF_REQUIRE_RE)) {
+        const relPath = match[1];
+        const parsed = parseFolder(node_path_1.default.dirname(relPath));
+        if (!parsed)
+            continue;
+        faces.set(`${parsed.weight}:${parsed.style}`, {
+            ...parsed,
+            path: `./node_modules/@expo-google-fonts/${packageName}/${relPath}`,
+            absPath: node_path_1.default.join(pkgDir, relPath),
+        });
+    }
+    return { fontFamily: family, faces };
+}
+/**
+ * Resolves the `@expo-google-fonts/<packageName>` package directory via
+ * `require.resolve`. This is the only side-effectful seam; keep it thin.
+ */
+function resolvePackageDir(packageName, projectRoot) {
+    try {
+        return node_path_1.default.dirname(require.resolve(`@expo-google-fonts/${packageName}/package.json`, {
+            paths: [projectRoot],
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Discovers a Google Fonts package: resolves it then parses its contents.
+ * Emits a warning and returns null when the package is missing or malformed.
+ */
+function discoverPackage(packageName, projectRoot, warnOnMissing) {
+    const pkgDir = resolvePackageDir(packageName, projectRoot);
+    if (!pkgDir) {
+        if (warnOnMissing) {
+            logger.warn(`@expo-google-fonts/${packageName} is not installed — run: npx expo install @expo-google-fonts/${packageName}`);
+        }
+        return null;
+    }
+    return parsePackage(pkgDir, packageName);
+}

package/build/google-fonts/index.d.ts

@@ -0,0 +1,43 @@
+import { ConfigPlugin } from "expo/config-plugins";
+export interface GoogleFontSpec {
+    packageName: string;
+    /** `fontFamily` style prop value — defaults to `metadata.json` family (e.g. `"Roboto"`). */
+    fontFamily?: string;
+    weights?: number[];
+    importItalic?: boolean;
+}
+export interface BuildExpoFontPluginOptionsInput {
+    fonts: GoogleFontSpec[];
+    projectRoot?: string;
+    warnOnMissing?: boolean;
+}
+interface ExpoFontPluginOptions {
+    android: {
+        fonts: {
+            fontFamily: string;
+            fontDefinitions: {
+                path: string;
+                weight: number;
+                style?: "italic";
+            }[];
+        }[];
+    };
+    ios: {
+        fonts: string[];
+    };
+}
+/**
+ * Builds the `expo-font` plugin options from installed `@expo-google-fonts/*`
+ * packages — Android uses `fontFamily` + weight/style, iOS embeds the resolved
+ * file paths. Use this directly only if you want to pass the options to
+ * `expo-font` yourself; most projects should use the {@link withExpoGoogleFonts}
+ * config plugin instead.
+ */
+export declare function buildExpoGoogleFontsOptions({ fonts, projectRoot, warnOnMissing, }: BuildExpoFontPluginOptionsInput): ExpoFontPluginOptions;
+export interface ExpoGoogleFontsProps {
+    fonts?: GoogleFontSpec[];
+    projectRoot?: string;
+    warnOnMissing?: boolean;
+}
+declare const _default: ConfigPlugin<ExpoGoogleFontsProps>;
+export default _default;

package/build/google-fonts/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExpoGoogleFontsOptions = buildExpoGoogleFontsOptions;
+const config_plugins_1 = require("expo/config-plugins");
+const node_fs_1 = __importDefault(require("node:fs"));
+const discovery_1 = require("./discovery");
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)("@vanenshi/expo-plugins/google-fonts");
+const pkg = require("../../package.json");
+/**
+ * Builds the `expo-font` plugin options from installed `@expo-google-fonts/*`
+ * packages — Android uses `fontFamily` + weight/style, iOS embeds the resolved
+ * file paths. Use this directly only if you want to pass the options to
+ * `expo-font` yourself; most projects should use the {@link withExpoGoogleFonts}
+ * config plugin instead.
+ */
+function buildExpoGoogleFontsOptions({ fonts, projectRoot = process.cwd(), warnOnMissing = true, }) {
+    const androidFonts = [];
+    const iosFonts = [];
+    for (const spec of fonts) {
+        const pkg = (0, discovery_1.discoverPackage)(spec.packageName, projectRoot, warnOnMissing);
+        if (!pkg)
+            continue;
+        const fontFamily = spec.fontFamily ?? pkg.fontFamily;
+        const weights = spec.weights ?? [400];
+        const wanted = weights.map((weight) => ({
+            weight,
+            style: "normal",
+        }));
+        if (spec.importItalic) {
+            wanted.push(...weights.map((weight) => ({ weight, style: "italic" })));
+        }
+        const fontDefinitions = [];
+        for (const { weight, style } of wanted) {
+            const face = pkg.faces.get(`${weight}:${style}`);
+            if (!face) {
+                if (warnOnMissing) {
+                    logger.warn(`${fontFamily} weight ${weight}${style === "italic" ? " italic" : ""} not found in @expo-google-fonts/${spec.packageName}.`);
+                }
+                continue;
+            }
+            if (!node_fs_1.default.existsSync(face.absPath)) {
+                if (warnOnMissing) {
+                    logger.warn(`${fontFamily} file missing: ${face.absPath}`);
+                }
+                continue;
+            }
+            fontDefinitions.push({
+                path: face.path,
+                weight: face.weight,
+                ...(face.style === "italic" ? { style: "italic" } : {}),
+            });
+        }
+        if (fontDefinitions.length === 0) {
+            if (warnOnMissing) {
+                logger.warn(`No faces embedded for ${fontFamily} (@expo-google-fonts/${spec.packageName}).`);
+            }
+            continue;
+        }
+        androidFonts.push({ fontFamily, fontDefinitions });
+        iosFonts.push(...fontDefinitions.map((def) => def.path));
+    }
+    return { android: { fonts: androidFonts }, ios: { fonts: iosFonts } };
+}
+/**
+ * Config plugin that embeds `@expo-google-fonts/*` faces into the native
+ * projects. Resolves the requested weights/styles and delegates to `expo-font`,
+ * so you don't need a separate `["expo-font", ...]` entry.
+ *
+ * @example
+ * // app.config.ts
+ * plugins: [
+ *   [
+ *     "@vanenshi/expo-plugins/google-fonts",
+ *     { fonts: [{ packageName: "roboto", weights: [400, 700], importItalic: true }] },
+ *   ],
+ * ]
+ */
+const withExpoGoogleFonts = (config, props) => {
+    if (!props?.fonts?.length)
+        return config;
+    const options = buildExpoGoogleFontsOptions(props);
+    const withFonts = require("expo-font/app.plugin").default;
+    return withFonts(config, options);
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withExpoGoogleFonts, "@vanenshi/expo-plugins/google-fonts", pkg.version);

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export { default as withDisplayName } from "./display-name";
+export type { DisplayNameProps } from "./display-name";
+export { default as withExpoGoogleFonts, buildExpoGoogleFontsOptions, } from "./google-fonts";
+export type { GoogleFontSpec, BuildExpoFontPluginOptionsInput, ExpoGoogleFontsProps, } from "./google-fonts";

package/build/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExpoGoogleFontsOptions = exports.withExpoGoogleFonts = exports.withDisplayName = void 0;
+var display_name_1 = require("./display-name");
+Object.defineProperty(exports, "withDisplayName", { enumerable: true, get: function () { return __importDefault(display_name_1).default; } });
+var google_fonts_1 = require("./google-fonts");
+Object.defineProperty(exports, "withExpoGoogleFonts", { enumerable: true, get: function () { return __importDefault(google_fonts_1).default; } });
+Object.defineProperty(exports, "buildExpoGoogleFontsOptions", { enumerable: true, get: function () { return google_fonts_1.buildExpoGoogleFontsOptions; } });

package/build/utils/logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Scoped logger for Expo config plugins.
+ */
+export declare function createLogger(scope: string): {
+    warnAndroid(text: string): void;
+    warnIOS(text: string): void;
+    warn(text: string): void;
+};

package/build/utils/logger.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const warned = new Set();
+const bold = (text) => `\x1b[1m${text}\x1b[22m`;
+const yellow = (text) => `\x1b[33m${text}\x1b[39m`;
+/**
+ * Scoped logger for Expo config plugins.
+ */
+function createLogger(scope) {
+    return {
+        warnAndroid(text) {
+            const warning = formatWarning({
+                platform: "android",
+                scope,
+                warning: text,
+            });
+            if (warned.has(warning))
+                return;
+            warned.add(warning);
+            console.warn(warning);
+        },
+        warnIOS(text) {
+            const warning = formatWarning({
+                platform: "ios",
+                scope,
+                warning: text,
+            });
+            if (warned.has(warning))
+                return;
+            warned.add(warning);
+            console.warn(warning);
+        },
+        warn(text) {
+            const warning = formatWarning({ warning: text });
+            if (warned.has(warning))
+                return;
+            warned.add(warning);
+            console.warn(formatWarning({ warning: text }));
+        },
+    };
+}
+/**
+ * » @expo-google-fonts/inter is not installed — run: npx expo install @expo-google-fonts/inter
+ * » @vanenshi/expo-plugins/display-name[android]: displayName is set — ignoring abstract "name": example-internal
+ * » @vanenshi/expo-plugins/display-name[ios]: displayName is set — ignoring abstract "name": example-internal
+ */
+function formatWarning({ platform, scope, warning, }) {
+    let prefix = "» ";
+    if (scope && platform) {
+        prefix += bold(`${scope}[${bold(platform)}]: `);
+    }
+    else if (scope) {
+        prefix += bold(`${scope}: `);
+    }
+    else if (platform) {
+        prefix += bold(`${platform}: `);
+    }
+    return yellow(`${prefix}${warning}`);
+}

package/display-name.js

@@ -0,0 +1,2 @@
+// Entry stub for "@vanenshi/expo-plugins/display-name"
+module.exports = require("./build/display-name").default;

package/google-fonts.js

@@ -0,0 +1,3 @@
+// Plugin entry so `app.json` can reference
+// "@vanenshi/expo-plugins/google-fonts".
+module.exports = require("./build/google-fonts").default;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@vanenshi/expo-plugins",
+  "version": "0.1.1",
+  "description": "A small collection of Expo config plugins.",
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "build",
+    "display-name.js",
+    "google-fonts.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vanenshi/expo-plugins.git"
+  },
+  "keywords": [
+    "react",
+    "react-native",
+    "expo",
+    "config-plugin",
+    "expo-plugins"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@expo/config-types": "^56.0.0",
+    "eslint": "^9.39.4",
+    "expo-module-scripts": "^56.0.3",
+    "jest": "^29.7.0"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "expo-font": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo-font": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "pnpm clean && expo-module build",
+    "clean": "expo-module clean && pnpm clean:example",
+    "clean:example": "rm -rf example/node_modules/@vanenshi",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "expo-module": "expo-module"
+  }
+}