react-native-icon-switcher 0.0.0-stage → 0.1.0

package/plugin/build/core/assets.js

@@ -0,0 +1,463 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planAssets = planAssets;
+exports.writeAssets = writeAssets;
+exports._readCornerRgb = _readCornerRgb;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const sharp_1 = __importDefault(require("sharp"));
+const LEGACY_DENSITIES = [
+    { folder: 'mipmap-mdpi', size: 48 },
+    { folder: 'mipmap-hdpi', size: 72 },
+    { folder: 'mipmap-xhdpi', size: 96 },
+    { folder: 'mipmap-xxhdpi', size: 144 },
+    { folder: 'mipmap-xxxhdpi', size: 192 },
+];
+const ADAPTIVE_DENSITIES = [
+    { folder: 'mipmap-mdpi', size: 108 },
+    { folder: 'mipmap-hdpi', size: 162 },
+    { folder: 'mipmap-xhdpi', size: 216 },
+    { folder: 'mipmap-xxhdpi', size: 324 },
+    { folder: 'mipmap-xxxhdpi', size: 432 },
+];
+const PNG_OPTIONS = { compressionLevel: 9, adaptiveFiltering: false };
+function _iosSetFolder(icon) {
+    return icon.isDefault
+        ? 'AppIcon.appiconset'
+        : `AppIcon-${icon.name}.appiconset`;
+}
+function _androidBaseName(icon) {
+    return icon.isDefault ? 'ic_launcher' : `ic_launcher_${icon.name}`;
+}
+function _colorResourceName(icon) {
+    return icon.isDefault
+        ? 'icon_switcher_default_background'
+        : `icon_switcher_${icon.name}_background`;
+}
+function _iosVariants(icon) {
+    if (!icon.ios) {
+        return [];
+    }
+    const out = [
+        { variant: 'light', source: icon.ios.light },
+    ];
+    if (icon.ios.dark) {
+        out.push({ variant: 'dark', source: icon.ios.dark });
+    }
+    if (icon.ios.tinted) {
+        out.push({ variant: 'tinted', source: icon.ios.tinted });
+    }
+    return out;
+}
+function _legacySource(icon) {
+    const android = icon.android;
+    if (!android) {
+        return null;
+    }
+    if ('legacy' in android) {
+        return android.legacy;
+    }
+    return null;
+}
+function _hasAdaptive(icon) {
+    const android = icon.android;
+    return android !== null && !('legacy' in android);
+}
+function planAssets(cfg, projectRoot) {
+    const assets = [];
+    const colorEntries = [];
+    for (const icon of cfg.icons) {
+        const setFolder = _iosSetFolder(icon);
+        const iosVariants = _iosVariants(icon);
+        if (iosVariants.length > 0) {
+            for (const { variant, source } of iosVariants) {
+                const filename = variant === 'light'
+                    ? 'AppIcon-1024.png'
+                    : `AppIcon-1024-${variant}.png`;
+                assets.push({
+                    relativePath: node_path_1.default.join(setFolder, filename),
+                    job: {
+                        kind: 'ios-png',
+                        iconName: icon.name,
+                        isDefault: icon.isDefault,
+                        variant,
+                        sourcePath: source,
+                        flattenOn: cfg.ios.flattenOn,
+                        width: 1024,
+                        height: 1024,
+                    },
+                });
+            }
+            assets.push({
+                relativePath: node_path_1.default.join(setFolder, 'Contents.json'),
+                job: {
+                    kind: 'ios-contents',
+                    iconName: icon.name,
+                    isDefault: icon.isDefault,
+                    variants: iosVariants.map((v) => v.variant),
+                },
+            });
+        }
+        const legacySource = _legacySource(icon);
+        if (legacySource) {
+            const base = _androidBaseName(icon);
+            for (const { folder, size } of LEGACY_DENSITIES) {
+                for (const round of [false, true]) {
+                    assets.push({
+                        relativePath: node_path_1.default.join(folder, `${base}${round ? '_round' : ''}.png`),
+                        job: {
+                            kind: 'android-legacy',
+                            iconName: icon.name,
+                            isDefault: icon.isDefault,
+                            round,
+                            sourcePath: legacySource,
+                            density: folder,
+                            size,
+                        },
+                    });
+                }
+            }
+        }
+        if (_hasAdaptive(icon)) {
+            const android = icon.android;
+            const base = _androidBaseName(icon);
+            const backgroundIsColor = typeof android.background === 'string' &&
+                android.background.startsWith('#');
+            const backgroundImagePath = typeof android.background === 'string' &&
+                !android.background.startsWith('#')
+                ? android.background
+                : undefined;
+            for (const { folder, size } of LEGACY_DENSITIES) {
+                for (const round of [false, true]) {
+                    assets.push({
+                        relativePath: node_path_1.default.join(folder, `${base}${round ? '_round' : ''}.png`),
+                        job: {
+                            kind: 'android-legacy',
+                            iconName: icon.name,
+                            isDefault: icon.isDefault,
+                            round,
+                            sourcePath: android.foreground,
+                            density: folder,
+                            size,
+                            backgroundColor: backgroundIsColor
+                                ? android.background
+                                : undefined,
+                            backgroundImagePath,
+                        },
+                    });
+                }
+            }
+            for (const { folder, size } of ADAPTIVE_DENSITIES) {
+                assets.push({
+                    relativePath: node_path_1.default.join(folder, `${base}_foreground.png`),
+                    job: {
+                        kind: 'android-adaptive-foreground',
+                        iconName: icon.name,
+                        isDefault: icon.isDefault,
+                        sourcePath: android.foreground,
+                        density: folder,
+                        size,
+                    },
+                });
+                if (typeof android.background === 'string' &&
+                    !android.background.startsWith('#')) {
+                    assets.push({
+                        relativePath: node_path_1.default.join(folder, `${base}_background.png`),
+                        job: {
+                            kind: 'android-adaptive-background-image',
+                            iconName: icon.name,
+                            isDefault: icon.isDefault,
+                            sourcePath: android.background,
+                            density: folder,
+                            size,
+                        },
+                    });
+                }
+                if (android.monochrome) {
+                    assets.push({
+                        relativePath: node_path_1.default.join(folder, `${base}_monochrome.png`),
+                        job: {
+                            kind: 'android-adaptive-foreground',
+                            iconName: icon.name,
+                            isDefault: icon.isDefault,
+                            sourcePath: android.monochrome,
+                            density: folder,
+                            size,
+                        },
+                    });
+                }
+            }
+            if (backgroundIsColor) {
+                colorEntries.push({
+                    resourceName: _colorResourceName(icon),
+                    color: android.background,
+                });
+            }
+            for (const round of [false, true]) {
+                assets.push({
+                    relativePath: node_path_1.default.join('mipmap-anydpi-v26', `${base}${round ? '_round' : ''}.xml`),
+                    job: {
+                        kind: 'android-adaptive-xml',
+                        iconName: icon.name,
+                        isDefault: icon.isDefault,
+                        round,
+                        backgroundIsColor,
+                        hasMonochrome: Boolean(android.monochrome),
+                    },
+                });
+            }
+        }
+    }
+    if (colorEntries.length > 0) {
+        const unique = new Map();
+        for (const e of colorEntries) {
+            unique.set(e.resourceName, e.color);
+        }
+        assets.push({
+            relativePath: node_path_1.default.join('values', 'icon_switcher_colors.xml'),
+            job: {
+                kind: 'android-colors-xml',
+                entries: [...unique.entries()].map(([resourceName, color]) => ({
+                    resourceName,
+                    color,
+                })),
+            },
+        });
+    }
+    return {
+        projectRoot,
+        flattenOn: cfg.ios.flattenOn,
+        assets,
+    };
+}
+function _hexToRgb(hex) {
+    let normalized = hex.slice(1);
+    if (normalized.length === 3) {
+        normalized = normalized
+            .split('')
+            .map((c) => c + c)
+            .join('');
+    }
+    const num = Number.parseInt(normalized, 16);
+    return {
+        r: (num >> 16) & 0xff,
+        g: (num >> 8) & 0xff,
+        b: num & 0xff,
+    };
+}
+async function _flattenPng(sourceAbs, flattenOn, width, height) {
+    const { r, g, b } = _hexToRgb(flattenOn);
+    const background = await (0, sharp_1.default)({
+        create: {
+            width,
+            height,
+            channels: 3,
+            background: { r, g, b },
+        },
+    })
+        .png(PNG_OPTIONS)
+        .toBuffer();
+    const resized = await (0, sharp_1.default)(sourceAbs)
+        .resize(width, height, {
+        fit: 'contain',
+        background: { r, g, b, alpha: 0 },
+    })
+        .png()
+        .toBuffer();
+    return (0, sharp_1.default)(background)
+        .composite([{ input: resized, blend: 'over' }])
+        .removeAlpha()
+        .png(PNG_OPTIONS)
+        .toBuffer();
+}
+async function _applyRoundMask(image, size) {
+    const mask = Buffer.from(`<svg width="${size}" height="${size}"><circle cx="${size / 2}" cy="${size / 2}" r="${size / 2}" fill="white"/></svg>`);
+    return (0, sharp_1.default)(image)
+        .composite([{ input: mask, blend: 'dest-in' }])
+        .png(PNG_OPTIONS)
+        .toBuffer();
+}
+async function _legacyPng(sourceAbs, size, round) {
+    const resized = await (0, sharp_1.default)(sourceAbs)
+        .resize(size, size, { fit: 'cover' })
+        .png()
+        .toBuffer();
+    if (!round) {
+        return (0, sharp_1.default)(resized).png(PNG_OPTIONS).toBuffer();
+    }
+    return _applyRoundMask(resized, size);
+}
+async function _legacyCompositePng(foregroundAbs, size, round, background) {
+    let base;
+    if ('color' in background) {
+        const { r, g, b } = _hexToRgb(background.color);
+        base = await (0, sharp_1.default)({
+            create: {
+                width: size,
+                height: size,
+                channels: 4,
+                background: { r, g, b, alpha: 255 },
+            },
+        })
+            .png()
+            .toBuffer();
+    }
+    else {
+        base = await (0, sharp_1.default)(background.imageAbs)
+            .resize(size, size, { fit: 'cover' })
+            .png()
+            .toBuffer();
+    }
+    const foreground = await (0, sharp_1.default)(foregroundAbs)
+        .resize(size, size, {
+        fit: 'contain',
+        background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+        .png()
+        .toBuffer();
+    const flat = await (0, sharp_1.default)(base)
+        .composite([{ input: foreground, blend: 'over' }])
+        .png(PNG_OPTIONS)
+        .toBuffer();
+    if (!round) {
+        return flat;
+    }
+    return _applyRoundMask(flat, size);
+}
+async function _resizePng(sourceAbs, size) {
+    return (0, sharp_1.default)(sourceAbs)
+        .resize(size, size, {
+        fit: 'contain',
+        background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+        .png(PNG_OPTIONS)
+        .toBuffer();
+}
+function _iosContentsJson(variants) {
+    const images = variants.map((variant) => {
+        const base = {
+            idiom: 'universal',
+            platform: 'ios',
+            size: '1024x1024',
+        };
+        const filename = variant === 'light' ? 'AppIcon-1024.png' : `AppIcon-1024-${variant}.png`;
+        if (variant === 'light') {
+            return { ...base, filename };
+        }
+        const appearanceValue = variant === 'dark' ? 'dark' : 'tinted';
+        return {
+            ...base,
+            filename,
+            appearances: [{ appearance: 'luminosity', value: appearanceValue }],
+        };
+    });
+    return `${JSON.stringify({
+        images,
+        info: { version: 1, author: 'xcode' },
+    }, null, 2)}\n`;
+}
+function _adaptiveXml(base, backgroundIsColor, colorResource, hasMonochrome) {
+    const backgroundRef = backgroundIsColor
+        ? `@color/${colorResource}`
+        : `@mipmap/${base}_background`;
+    const lines = [
+        '<?xml version="1.0" encoding="utf-8"?>',
+        '<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">',
+        `    <background android:drawable="${backgroundRef}" />`,
+        `    <foreground android:drawable="@mipmap/${base}_foreground" />`,
+    ];
+    if (hasMonochrome) {
+        lines.push(`    <monochrome android:drawable="@mipmap/${base}_monochrome" />`);
+    }
+    lines.push('</adaptive-icon>', '');
+    return lines.join('\n');
+}
+function _colorsXml(entries) {
+    const lines = ['<?xml version="1.0" encoding="utf-8"?>', '<resources>'];
+    for (const { resourceName, color } of entries) {
+        lines.push(`    <color name="${resourceName}">${color}</color>`);
+    }
+    lines.push('</resources>', '');
+    return lines.join('\n');
+}
+async function _writeBuffer(abs, data) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(abs), { recursive: true });
+    await promises_1.default.writeFile(abs, data);
+    return node_crypto_1.default.createHash('sha256').update(data).digest('hex');
+}
+async function _writeText(abs, text) {
+    const data = Buffer.from(text, 'utf8');
+    return _writeBuffer(abs, data);
+}
+async function _renderJob(plan, job) {
+    const root = plan.projectRoot;
+    switch (job.kind) {
+        case 'ios-png':
+            return _flattenPng(node_path_1.default.join(root, job.sourcePath), job.flattenOn, job.width, job.height);
+        case 'ios-contents':
+            return _iosContentsJson(job.variants);
+        case 'android-legacy': {
+            const foregroundAbs = node_path_1.default.join(root, job.sourcePath);
+            if (job.backgroundColor !== undefined) {
+                return _legacyCompositePng(foregroundAbs, job.size, job.round, {
+                    color: job.backgroundColor,
+                });
+            }
+            if (job.backgroundImagePath !== undefined) {
+                return _legacyCompositePng(foregroundAbs, job.size, job.round, {
+                    imageAbs: node_path_1.default.join(root, job.backgroundImagePath),
+                });
+            }
+            return _legacyPng(foregroundAbs, job.size, job.round);
+        }
+        case 'android-adaptive-foreground':
+        case 'android-adaptive-background-image':
+            return _resizePng(node_path_1.default.join(root, job.sourcePath), job.size);
+        case 'android-adaptive-xml': {
+            const base = job.isDefault
+                ? 'ic_launcher'
+                : `ic_launcher_${job.iconName}`;
+            const colorResource = job.isDefault
+                ? 'icon_switcher_default_background'
+                : `icon_switcher_${job.iconName}_background`;
+            return _adaptiveXml(base, job.backgroundIsColor, colorResource, job.hasMonochrome);
+        }
+        case 'android-colors-xml':
+            return _colorsXml(job.entries);
+        default: {
+            const _exhaustive = job;
+            return _exhaustive;
+        }
+    }
+}
+async function writeAssets(plan, opts) {
+    const written = [];
+    for (const asset of plan.assets) {
+        const isIos = asset.relativePath.includes('.appiconset');
+        const baseDir = isIos ? opts.iosAssetCatalog : opts.androidResDir;
+        const absolutePath = node_path_1.default.join(baseDir, asset.relativePath);
+        const payload = await _renderJob(plan, asset.job);
+        const sha256 = typeof payload === 'string'
+            ? await _writeText(absolutePath, payload)
+            : await _writeBuffer(absolutePath, payload);
+        written.push({
+            relativePath: asset.relativePath,
+            absolutePath,
+            sha256,
+        });
+    }
+    return written;
+}
+/** Test helper: corner pixel RGB after iOS flatten (alpha removed). */
+async function _readCornerRgb(pngPath) {
+    var _a, _b, _c;
+    const { data } = await (0, sharp_1.default)(pngPath)
+        .extract({ left: 0, top: 0, width: 1, height: 1 })
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    return { r: (_a = data[0]) !== null && _a !== void 0 ? _a : 0, g: (_b = data[1]) !== null && _b !== void 0 ? _b : 0, b: (_c = data[2]) !== null && _c !== void 0 ? _c : 0 };
+}

package/plugin/build/core/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class ConfigError extends Error {
+    readonly name = "ConfigError";
+    constructor(message: string);
+}

package/plugin/build/core/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigError = void 0;
+class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ConfigError = ConfigError;

package/plugin/build/core/validate.d.ts

@@ -0,0 +1,6 @@
+import type { IconSwitcherConfig, IconSource, ResolvedConfig } from '../types';
+export interface ResolveConfigContext {
+    projectRoot: string;
+    expoDefault?: IconSource;
+}
+export declare function resolveConfig(cfg: IconSwitcherConfig, ctx: ResolveConfigContext): ResolvedConfig;