app-icon-badge-next 0.2.0

package/dist/index.js

@@ -0,0 +1,252 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  addBadge: () => addBadge
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
+var import_jimp2 = __toESM(require("jimp"));
+
+// src/core/validation.ts
+var import_zod = require("zod");
+var hexColor = import_zod.z.string().regex(/^#[0-9a-fA-F]{6}$/);
+var baseBadge = {
+  text: import_zod.z.string().min(1),
+  color: import_zod.z.enum(["white", "black"]).default("white"),
+  background: hexColor.optional(),
+  fontScale: import_zod.z.number().min(0.5).max(2).default(1),
+  letterSpacing: import_zod.z.number().min(0).max(10).default(0),
+  padding: import_zod.z.number().min(0).max(120).default(0),
+  opacity: import_zod.z.number().min(0).max(1).default(1)
+};
+var banner = import_zod.z.object({
+  type: import_zod.z.literal("banner"),
+  position: import_zod.z.enum(["top", "bottom"]).default("bottom"),
+  ...baseBadge
+});
+var ribbon = import_zod.z.object({
+  type: import_zod.z.literal("ribbon"),
+  position: import_zod.z.enum(["left", "right"]).default("right"),
+  ...baseBadge
+});
+var badgeSchema = import_zod.z.discriminatedUnion("type", [banner, ribbon]);
+var addBadgeParamsSchema = import_zod.z.object({
+  icon: import_zod.z.string().min(1),
+  dstPath: import_zod.z.string().optional(),
+  badges: import_zod.z.array(badgeSchema).min(1),
+  isAdaptiveIcon: import_zod.z.boolean().default(false),
+  adaptiveSafeMode: import_zod.z.boolean().default(true),
+  safeZoneScale: import_zod.z.number().min(0.4).max(1).default(0.72),
+  debug: import_zod.z.boolean().default(false),
+  dryRun: import_zod.z.boolean().default(false)
+});
+var pluginOptionsSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  badges: import_zod.z.array(badgeSchema).optional(),
+  ios: import_zod.z.object({ badges: import_zod.z.array(badgeSchema).optional() }).default({}),
+  android: import_zod.z.object({
+    badges: import_zod.z.array(badgeSchema).optional(),
+    safeZoneScale: import_zod.z.number().min(0.4).max(1).default(0.72)
+  }).default({}),
+  adaptiveSafeMode: import_zod.z.boolean().default(true),
+  cache: import_zod.z.boolean().default(true),
+  debug: import_zod.z.boolean().default(false),
+  dryRun: import_zod.z.boolean().default(false)
+});
+
+// src/core/render.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_color_convert = __toESM(require("color-convert"));
+var import_delta_e = __toESM(require("delta-e"));
+var import_jimp = __toESM(require("jimp"));
+
+// src/core/fonts.ts
+var import_node_path = __toESM(require("path"));
+function getFontPath(isAdaptiveIcon, isBlack, scale = 1) {
+  const useLarge = scale >= 1 && !isAdaptiveIcon;
+  const fontPrefix = useLarge ? "128" : "64";
+  const color = isBlack ? "black" : "white";
+  return import_node_path.default.resolve(__dirname, `./assets/fonts/open-sans-${fontPrefix}-${color}.fnt`);
+}
+
+// src/core/utils.ts
+var import_node_crypto = __toESM(require("crypto"));
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+function withLetterSpacing(input, spacing = 0) {
+  if (spacing <= 0) return input;
+  const gap = " ".repeat(Math.max(1, Math.round(spacing)));
+  return input.split("").join(gap);
+}
+
+// src/core/render.ts
+function replaceColor(image, from, to) {
+  const fromColor = import_color_convert.default.hex.lab(from);
+  const toColor = import_color_convert.default.hex.rgb(to);
+  image.scan(0, 0, image.bitmap.width, image.bitmap.height, (_x, _y, idx) => {
+    if (image.bitmap.data[idx + 3] === 0) return;
+    const currentLABColor = import_color_convert.default.rgb.lab([
+      image.bitmap.data[idx],
+      image.bitmap.data[idx + 1],
+      image.bitmap.data[idx + 2]
+    ]);
+    const delta = import_delta_e.default.getDeltaE00(
+      { L: currentLABColor[0], A: currentLABColor[1], B: currentLABColor[2] },
+      { L: fromColor[0], A: fromColor[1], B: fromColor[2] }
+    );
+    if (delta <= 2.3) {
+      image.bitmap.data[idx] = toColor[0];
+      image.bitmap.data[idx + 1] = toColor[1];
+      image.bitmap.data[idx + 2] = toColor[2];
+    }
+  });
+}
+async function loadOverlay(overlayPath, background) {
+  const overlay = await import_jimp.default.read(overlayPath);
+  if (background) {
+    replaceColor(overlay, "#000000", background);
+  }
+  return overlay;
+}
+async function createBadgeImage(badge, isAdaptiveIcon) {
+  const variant = isAdaptiveIcon ? "-adaptive" : "";
+  const overlayPath = import_node_path3.default.resolve(__dirname, `./assets/${badge.type}-overlay${variant}.png`);
+  if (!import_node_fs2.default.existsSync(overlayPath)) {
+    throw new Error(`Overlay not found: ${overlayPath}`);
+  }
+  const overlay = await loadOverlay(overlayPath, badge.background);
+  const font = await import_jimp.default.loadFont(
+    getFontPath(isAdaptiveIcon, badge.color === "black", badge.fontScale)
+  );
+  const text = withLetterSpacing(
+    badge.type === "banner" ? badge.text.toUpperCase() : badge.text,
+    badge.letterSpacing
+  );
+  const padding = badge.padding;
+  const base = overlay.clone();
+  if (badge.opacity < 1) {
+    base.opacity(badge.opacity);
+  }
+  if (badge.type === "banner") {
+    const bannerHeight = isAdaptiveIcon ? 310 : 180;
+    const textContainer2 = new import_jimp.default(overlay.bitmap.width, bannerHeight, "transparent");
+    const alignY = isAdaptiveIcon ? badge.position === "top" ? import_jimp.default.VERTICAL_ALIGN_BOTTOM : import_jimp.default.VERTICAL_ALIGN_TOP : import_jimp.default.VERTICAL_ALIGN_MIDDLE;
+    textContainer2.print(
+      font,
+      padding,
+      0,
+      { text, alignmentX: import_jimp.default.HORIZONTAL_ALIGN_CENTER, alignmentY: alignY },
+      overlay.bitmap.width - padding * 2,
+      bannerHeight
+    );
+    const top = badge.position === "top";
+    base.flip(false, top);
+    base.composite(textContainer2, 0, top ? 0 : base.bitmap.height - bannerHeight);
+    return base;
+  }
+  const ribbonHeight = isAdaptiveIcon ? 100 : 180;
+  const translateBy = (isAdaptiveIcon ? 80 : 270) - padding;
+  const textContainer = new import_jimp.default(overlay.bitmap.width, ribbonHeight, "transparent");
+  textContainer.print(
+    font,
+    0,
+    0,
+    { text, alignmentX: import_jimp.default.HORIZONTAL_ALIGN_CENTER, alignmentY: import_jimp.default.VERTICAL_ALIGN_MIDDLE },
+    overlay.bitmap.width,
+    ribbonHeight
+  );
+  const left = badge.position === "left";
+  textContainer.rotate(left ? 45 : -45);
+  const translateX = left ? -translateBy : translateBy;
+  const textX = left ? translateX : overlay.bitmap.width - textContainer.bitmap.width + translateX;
+  const textY = left ? translateX : -translateX;
+  base.flip(left, false);
+  base.composite(textContainer, textX, textY);
+  return base;
+}
+function applyAdaptiveSafeZone(badge, safeZoneScale) {
+  const canvas = new import_jimp.default(badge.bitmap.width, badge.bitmap.height, "transparent");
+  const scaled = badge.resize(
+    Math.round(badge.bitmap.width * safeZoneScale),
+    Math.round(badge.bitmap.height * safeZoneScale)
+  );
+  const x = Math.round((canvas.bitmap.width - scaled.bitmap.width) / 2);
+  const y = Math.round((canvas.bitmap.height - scaled.bitmap.height) / 2);
+  canvas.composite(scaled, x, y);
+  return canvas;
+}
+
+// src/index.ts
+function getResultPath(icon) {
+  const parts = icon.split(".");
+  parts.splice(parts.length - 1, 0, "result");
+  return parts.join(".");
+}
+function logDebug(debug, payload) {
+  if (!debug) return;
+  process.stdout.write(`[app-icon-badge-next] ${JSON.stringify(payload)}
+`);
+}
+async function addBadge(input) {
+  const parsed = addBadgeParamsSchema.parse(input);
+  const sourcePath = import_node_path4.default.resolve(parsed.icon);
+  if (!import_node_fs3.default.existsSync(sourcePath)) {
+    throw new Error(`Icon does not exist: ${sourcePath}`);
+  }
+  const destination = import_node_path4.default.resolve(parsed.dstPath ?? getResultPath(parsed.icon));
+  logDebug(parsed.debug, {
+    icon: sourcePath,
+    dstPath: destination,
+    isAdaptiveIcon: parsed.isAdaptiveIcon,
+    adaptiveSafeMode: parsed.adaptiveSafeMode,
+    safeZoneScale: parsed.safeZoneScale,
+    badgeCount: parsed.badges.length
+  });
+  if (parsed.dryRun) {
+    return destination;
+  }
+  const image = await import_jimp2.default.read(sourcePath);
+  for (const badge of parsed.badges) {
+    const badgeImage = await createBadgeImage(badge, parsed.isAdaptiveIcon);
+    const finalBadge = parsed.isAdaptiveIcon && parsed.adaptiveSafeMode ? applyAdaptiveSafeZone(badgeImage, parsed.safeZoneScale) : badgeImage;
+    image.composite(finalBadge, 0, 0);
+  }
+  import_node_fs3.default.mkdirSync(import_node_path4.default.dirname(destination), { recursive: true });
+  await image.writeAsync(destination);
+  return destination;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addBadge
+});

package/dist/index.mjs

@@ -0,0 +1,217 @@
+// src/index.ts
+import fs3 from "fs";
+import path4 from "path";
+import Jimp2 from "jimp";
+
+// src/core/validation.ts
+import { z } from "zod";
+var hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/);
+var baseBadge = {
+  text: z.string().min(1),
+  color: z.enum(["white", "black"]).default("white"),
+  background: hexColor.optional(),
+  fontScale: z.number().min(0.5).max(2).default(1),
+  letterSpacing: z.number().min(0).max(10).default(0),
+  padding: z.number().min(0).max(120).default(0),
+  opacity: z.number().min(0).max(1).default(1)
+};
+var banner = z.object({
+  type: z.literal("banner"),
+  position: z.enum(["top", "bottom"]).default("bottom"),
+  ...baseBadge
+});
+var ribbon = z.object({
+  type: z.literal("ribbon"),
+  position: z.enum(["left", "right"]).default("right"),
+  ...baseBadge
+});
+var badgeSchema = z.discriminatedUnion("type", [banner, ribbon]);
+var addBadgeParamsSchema = z.object({
+  icon: z.string().min(1),
+  dstPath: z.string().optional(),
+  badges: z.array(badgeSchema).min(1),
+  isAdaptiveIcon: z.boolean().default(false),
+  adaptiveSafeMode: z.boolean().default(true),
+  safeZoneScale: z.number().min(0.4).max(1).default(0.72),
+  debug: z.boolean().default(false),
+  dryRun: z.boolean().default(false)
+});
+var pluginOptionsSchema = z.object({
+  enabled: z.boolean().default(true),
+  badges: z.array(badgeSchema).optional(),
+  ios: z.object({ badges: z.array(badgeSchema).optional() }).default({}),
+  android: z.object({
+    badges: z.array(badgeSchema).optional(),
+    safeZoneScale: z.number().min(0.4).max(1).default(0.72)
+  }).default({}),
+  adaptiveSafeMode: z.boolean().default(true),
+  cache: z.boolean().default(true),
+  debug: z.boolean().default(false),
+  dryRun: z.boolean().default(false)
+});
+
+// src/core/render.ts
+import fs2 from "fs";
+import path3 from "path";
+import colorConvert from "color-convert";
+import DeltaE from "delta-e";
+import Jimp from "jimp";
+
+// src/core/fonts.ts
+import path from "path";
+function getFontPath(isAdaptiveIcon, isBlack, scale = 1) {
+  const useLarge = scale >= 1 && !isAdaptiveIcon;
+  const fontPrefix = useLarge ? "128" : "64";
+  const color = isBlack ? "black" : "white";
+  return path.resolve(__dirname, `./assets/fonts/open-sans-${fontPrefix}-${color}.fnt`);
+}
+
+// src/core/utils.ts
+import crypto from "crypto";
+import fs from "fs";
+import path2 from "path";
+function withLetterSpacing(input, spacing = 0) {
+  if (spacing <= 0) return input;
+  const gap = " ".repeat(Math.max(1, Math.round(spacing)));
+  return input.split("").join(gap);
+}
+
+// src/core/render.ts
+function replaceColor(image, from, to) {
+  const fromColor = colorConvert.hex.lab(from);
+  const toColor = colorConvert.hex.rgb(to);
+  image.scan(0, 0, image.bitmap.width, image.bitmap.height, (_x, _y, idx) => {
+    if (image.bitmap.data[idx + 3] === 0) return;
+    const currentLABColor = colorConvert.rgb.lab([
+      image.bitmap.data[idx],
+      image.bitmap.data[idx + 1],
+      image.bitmap.data[idx + 2]
+    ]);
+    const delta = DeltaE.getDeltaE00(
+      { L: currentLABColor[0], A: currentLABColor[1], B: currentLABColor[2] },
+      { L: fromColor[0], A: fromColor[1], B: fromColor[2] }
+    );
+    if (delta <= 2.3) {
+      image.bitmap.data[idx] = toColor[0];
+      image.bitmap.data[idx + 1] = toColor[1];
+      image.bitmap.data[idx + 2] = toColor[2];
+    }
+  });
+}
+async function loadOverlay(overlayPath, background) {
+  const overlay = await Jimp.read(overlayPath);
+  if (background) {
+    replaceColor(overlay, "#000000", background);
+  }
+  return overlay;
+}
+async function createBadgeImage(badge, isAdaptiveIcon) {
+  const variant = isAdaptiveIcon ? "-adaptive" : "";
+  const overlayPath = path3.resolve(__dirname, `./assets/${badge.type}-overlay${variant}.png`);
+  if (!fs2.existsSync(overlayPath)) {
+    throw new Error(`Overlay not found: ${overlayPath}`);
+  }
+  const overlay = await loadOverlay(overlayPath, badge.background);
+  const font = await Jimp.loadFont(
+    getFontPath(isAdaptiveIcon, badge.color === "black", badge.fontScale)
+  );
+  const text = withLetterSpacing(
+    badge.type === "banner" ? badge.text.toUpperCase() : badge.text,
+    badge.letterSpacing
+  );
+  const padding = badge.padding;
+  const base = overlay.clone();
+  if (badge.opacity < 1) {
+    base.opacity(badge.opacity);
+  }
+  if (badge.type === "banner") {
+    const bannerHeight = isAdaptiveIcon ? 310 : 180;
+    const textContainer2 = new Jimp(overlay.bitmap.width, bannerHeight, "transparent");
+    const alignY = isAdaptiveIcon ? badge.position === "top" ? Jimp.VERTICAL_ALIGN_BOTTOM : Jimp.VERTICAL_ALIGN_TOP : Jimp.VERTICAL_ALIGN_MIDDLE;
+    textContainer2.print(
+      font,
+      padding,
+      0,
+      { text, alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER, alignmentY: alignY },
+      overlay.bitmap.width - padding * 2,
+      bannerHeight
+    );
+    const top = badge.position === "top";
+    base.flip(false, top);
+    base.composite(textContainer2, 0, top ? 0 : base.bitmap.height - bannerHeight);
+    return base;
+  }
+  const ribbonHeight = isAdaptiveIcon ? 100 : 180;
+  const translateBy = (isAdaptiveIcon ? 80 : 270) - padding;
+  const textContainer = new Jimp(overlay.bitmap.width, ribbonHeight, "transparent");
+  textContainer.print(
+    font,
+    0,
+    0,
+    { text, alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER, alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE },
+    overlay.bitmap.width,
+    ribbonHeight
+  );
+  const left = badge.position === "left";
+  textContainer.rotate(left ? 45 : -45);
+  const translateX = left ? -translateBy : translateBy;
+  const textX = left ? translateX : overlay.bitmap.width - textContainer.bitmap.width + translateX;
+  const textY = left ? translateX : -translateX;
+  base.flip(left, false);
+  base.composite(textContainer, textX, textY);
+  return base;
+}
+function applyAdaptiveSafeZone(badge, safeZoneScale) {
+  const canvas = new Jimp(badge.bitmap.width, badge.bitmap.height, "transparent");
+  const scaled = badge.resize(
+    Math.round(badge.bitmap.width * safeZoneScale),
+    Math.round(badge.bitmap.height * safeZoneScale)
+  );
+  const x = Math.round((canvas.bitmap.width - scaled.bitmap.width) / 2);
+  const y = Math.round((canvas.bitmap.height - scaled.bitmap.height) / 2);
+  canvas.composite(scaled, x, y);
+  return canvas;
+}
+
+// src/index.ts
+function getResultPath(icon) {
+  const parts = icon.split(".");
+  parts.splice(parts.length - 1, 0, "result");
+  return parts.join(".");
+}
+function logDebug(debug, payload) {
+  if (!debug) return;
+  process.stdout.write(`[app-icon-badge-next] ${JSON.stringify(payload)}
+`);
+}
+async function addBadge(input) {
+  const parsed = addBadgeParamsSchema.parse(input);
+  const sourcePath = path4.resolve(parsed.icon);
+  if (!fs3.existsSync(sourcePath)) {
+    throw new Error(`Icon does not exist: ${sourcePath}`);
+  }
+  const destination = path4.resolve(parsed.dstPath ?? getResultPath(parsed.icon));
+  logDebug(parsed.debug, {
+    icon: sourcePath,
+    dstPath: destination,
+    isAdaptiveIcon: parsed.isAdaptiveIcon,
+    adaptiveSafeMode: parsed.adaptiveSafeMode,
+    safeZoneScale: parsed.safeZoneScale,
+    badgeCount: parsed.badges.length
+  });
+  if (parsed.dryRun) {
+    return destination;
+  }
+  const image = await Jimp2.read(sourcePath);
+  for (const badge of parsed.badges) {
+    const badgeImage = await createBadgeImage(badge, parsed.isAdaptiveIcon);
+    const finalBadge = parsed.isAdaptiveIcon && parsed.adaptiveSafeMode ? applyAdaptiveSafeZone(badgeImage, parsed.safeZoneScale) : badgeImage;
+    image.composite(finalBadge, 0, 0);
+  }
+  fs3.mkdirSync(path4.dirname(destination), { recursive: true });
+  await image.writeAsync(destination);
+  return destination;
+}
+export {
+  addBadge
+};

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "app-icon-badge-next",
+  "version": "0.2.0",
+  "description": "Production-ready app icon badging for Expo and React Native: overlay environment and version badges on iOS and Android app icons via an Expo config plugin, library API, or CLI.",
+  "keywords": [
+    "expo",
+    "expo-config-plugin",
+    "react-native",
+    "app-icon",
+    "icon",
+    "badge",
+    "adaptive-icon",
+    "ios",
+    "android",
+    "eas"
+  ],
+  "license": "MIT",
+  "author": "AdzeB",
+  "homepage": "https://github.com/AdzeB/app-icon-badge-next#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AdzeB/app-icon-badge-next.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AdzeB/app-icon-badge-next/issues"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./types.ts"
+    },
+    "./app.plugin.js": "./app.plugin.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "app-icon-badge-next": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "app.plugin.js",
+    "types.ts"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "packageManager": "pnpm@11.1.0",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts && cp -R src/assets dist && tsup src/plugin/app.plugin.ts src/plugin/generate.ts --format cjs --out-dir dist && tsup src/cli.ts --format cjs --out-dir dist",
+    "type-check": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "test": "node --test test/*.test.js",
+    "test:update-snapshots": "node test/icon-snapshots.test.js --update",
+    "changeset": "changeset",
+    "release": "pnpm build && changeset publish",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "color-convert": "^2.0.1",
+    "commander": "^11.0.0",
+    "delta-e": "^0.0.8",
+    "jimp": "^0.22.7",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.10",
+    "@expo/config-plugins": "^57.0.2",
+    "@types/node": "^22.7.8",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.3"
+  }
+}

package/types.ts

@@ -0,0 +1,55 @@
+export type BadgeTextColor = 'white' | 'black';
+
+export type BannerBadge = {
+  type: 'banner';
+  text: string;
+  position?: 'top' | 'bottom';
+  color?: BadgeTextColor;
+  background?: string;
+  fontScale?: number;
+  letterSpacing?: number;
+  padding?: number;
+  opacity?: number;
+};
+
+export type RibbonBadge = {
+  type: 'ribbon';
+  text: string;
+  position?: 'left' | 'right';
+  color?: BadgeTextColor;
+  background?: string;
+  fontScale?: number;
+  letterSpacing?: number;
+  padding?: number;
+  opacity?: number;
+};
+
+export type Badge = BannerBadge | RibbonBadge;
+
+export type PlatformBadgeConfig = {
+  badges?: Badge[];
+};
+
+export type AppIconBadgeConfig = {
+  enabled?: boolean;
+  badges?: Badge[];
+  ios?: PlatformBadgeConfig;
+  android?: PlatformBadgeConfig & {
+    safeZoneScale?: number;
+  };
+  adaptiveSafeMode?: boolean;
+  cache?: boolean;
+  debug?: boolean;
+  dryRun?: boolean;
+};
+
+export type AddBadgeParams = {
+  icon: string;
+  dstPath?: string;
+  badges: Badge[];
+  isAdaptiveIcon?: boolean;
+  adaptiveSafeMode?: boolean;
+  safeZoneScale?: number;
+  debug?: boolean;
+  dryRun?: boolean;
+};