purgetss 7.5.2 → 7.6.1

package/src/core/branding/gen-android-adaptive.js

@@ -0,0 +1,116 @@
+/**
+ * PurgeTSS - gen-android-adaptive
+ *
+ * Adaptive icon triplet (foreground + background + monochrome) at 5 densities.
+ *
+ * Android adaptive icon: 108×108dp canvas, 66×66dp safe-zone.
+ * Densities: mdpi=108, hdpi=162, xhdpi=216, xxhdpi=324, xxxhdpi=432.
+ *
+ *   foreground:  logo centered inside safe-zone, transparent outside
+ *   background:  solid color filling the full canvas
+ *   monochrome:  foreground silhouette in white, alpha preserved
+ *                (Android applies themed tint at runtime on API 31+ — this
+ *                 layer is Android's dark/light mode mechanism for app icons)
+ *
+ * @fileoverview Android adaptive icons × 5 densities
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+export const DENSITIES = [
+  { name: 'mdpi', size: 108 },
+  { name: 'hdpi', size: 162 },
+  { name: 'xhdpi', size: 216 },
+  { name: 'xxhdpi', size: 324 },
+  { name: 'xxxhdpi', size: 432 }
+]
+
+export async function genAndroidAdaptive(tightMaster, bgColor, paddingPct, resRoot, opts = {}) {
+  const { monoTight = null } = opts
+  const generated = []
+
+  for (const { name, size } of DENSITIES) {
+    const inner = Math.floor((size * (100 - 2 * paddingPct)) / 100)
+    const dir = path.join(resRoot, `mipmap-${name}`)
+    fs.mkdirSync(dir, { recursive: true })
+
+    const foregroundPath = path.join(dir, 'ic_launcher_foreground.png')
+    const backgroundPath = path.join(dir, 'ic_launcher_background.png')
+    const monochromePath = path.join(dir, 'ic_launcher_monochrome.png')
+
+    // Foreground: logo sized to inner, centered on transparent canvas
+    const innerLogo = await sharp(tightMaster)
+      .resize({
+        width: inner,
+        height: inner,
+        fit: 'inside',
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      })
+      .toBuffer()
+
+    await sharp({
+      create: {
+        width: size,
+        height: size,
+        channels: 4,
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      }
+    })
+      .composite([{ input: innerLogo, gravity: 'center' }])
+      .png({ compressionLevel: 9 })
+      .toFile(foregroundPath)
+
+    // Background: solid color
+    await sharp({
+      create: {
+        width: size,
+        height: size,
+        channels: 4,
+        background: bgColor
+      }
+    })
+      .png({ compressionLevel: 9 })
+      .toFile(backgroundPath)
+
+    // Monochrome: white silhouette with preserved alpha.
+    if (monoTight) {
+      const innerMono = await sharp(monoTight)
+        .resize({
+          width: inner,
+          height: inner,
+          fit: 'inside',
+          background: { r: 0, g: 0, b: 0, alpha: 0 }
+        })
+        .toBuffer()
+
+      await sharp({
+        create: {
+          width: size,
+          height: size,
+          channels: 4,
+          background: { r: 0, g: 0, b: 0, alpha: 0 }
+        }
+      })
+        .composite([{ input: innerMono, gravity: 'center' }])
+        .ensureAlpha()
+        .linear([0, 0, 0, 1], [255, 255, 255, 0])
+        .png({ compressionLevel: 9 })
+        .toFile(monochromePath)
+    } else {
+      await sharp(foregroundPath)
+        .ensureAlpha()
+        .linear([0, 0, 0, 1], [255, 255, 255, 0])
+        .png({ compressionLevel: 9 })
+        .toFile(monochromePath)
+    }
+
+    generated.push(foregroundPath, backgroundPath, monochromePath)
+  }
+
+  fs.mkdirSync(path.join(resRoot, 'mipmap-anydpi-v26'), { recursive: true })
+
+  return generated
+}

package/src/core/branding/gen-android-legacy.js

@@ -0,0 +1,63 @@
+/**
+ * PurgeTSS - gen-android-legacy
+ *
+ * Flat ic_launcher.png for pre-adaptive Android (API 21–25, ~3% of users in 2026).
+ * Composites foreground over background, scaled to legacy launcher sizes.
+ *
+ * Legacy densities: mdpi=48, hdpi=72, xhdpi=96, xxhdpi=144, xxxhdpi=192.
+ *
+ * @fileoverview Legacy ic_launcher.png × 5 densities
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+export const LEGACY_DENSITIES = [
+  { name: 'mdpi', size: 48 },
+  { name: 'hdpi', size: 72 },
+  { name: 'xhdpi', size: 96 },
+  { name: 'xxhdpi', size: 144 },
+  { name: 'xxxhdpi', size: 192 }
+]
+
+export async function genAndroidLegacy(tightMaster, bgColor, paddingPct, resRoot) {
+  const generated = []
+  // Legacy icons have no adaptive mask — they render as drawn. Use ~60% of
+  // the adaptive padding so the logo fills more of the canvas.
+  const legacyPadding = Math.floor((paddingPct * 60) / 100)
+
+  for (const { name, size } of LEGACY_DENSITIES) {
+    const inner = Math.floor((size * (100 - 2 * legacyPadding)) / 100)
+    const dir = path.join(resRoot, `mipmap-${name}`)
+    fs.mkdirSync(dir, { recursive: true })
+
+    const outPath = path.join(dir, 'ic_launcher.png')
+
+    const innerLogo = await sharp(tightMaster)
+      .resize({
+        width: inner,
+        height: inner,
+        fit: 'inside',
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      })
+      .toBuffer()
+
+    await sharp({
+      create: {
+        width: size,
+        height: size,
+        channels: 4,
+        background: bgColor
+      }
+    })
+      .composite([{ input: innerLogo, gravity: 'center' }])
+      .png({ compressionLevel: 9 })
+      .toFile(outPath)
+
+    generated.push(outPath)
+  }
+
+  return generated
+}

package/src/core/branding/gen-ic-launcher-xml.js

@@ -0,0 +1,29 @@
+/**
+ * PurgeTSS - gen-ic-launcher-xml
+ *
+ * Writes the adaptive-icon XML binder to mipmap-anydpi-v26/ic_launcher.xml.
+ * Titanium/Android loads this file on API 26+ to pick up the adaptive icon triplet
+ * (foreground + background + monochrome).
+ *
+ * @fileoverview Adaptive-icon XML binder
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+
+export const IC_LAUNCHER_XML = `<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@mipmap/ic_launcher_background"/>
+  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <monochrome android:drawable="@mipmap/ic_launcher_monochrome"/>
+</adaptive-icon>
+`
+
+export function genIcLauncherXml(resRoot) {
+  const dir = path.join(resRoot, 'mipmap-anydpi-v26')
+  fs.mkdirSync(dir, { recursive: true })
+  const outPath = path.join(dir, 'ic_launcher.xml')
+  fs.writeFileSync(outPath, IC_LAUNCHER_XML, 'utf8')
+  return outPath
+}

package/src/core/branding/gen-ios-dark.js

@@ -0,0 +1,70 @@
+/**
+ * PurgeTSS - gen-ios-dark
+ *
+ * Produces Titanium's iOS 18+ dark-mode root icon:
+ *
+ *   DefaultIcon-Dark.png   1024×1024, transparent (default) or flattened on dark bg
+ *
+ * Per Apple HIG (iOS 18+): the dark variant may either (a) omit the background
+ * so the system applies its own dark gradient, or (b) use an opaque dark tint.
+ * Default here is (a) — transparent — per Apple's recommended approach.
+ *
+ * Titanium SDK 13.1+ is expected to read this file from the project root, but
+ * upstream issue tidev/titanium-sdk#14122 is not yet merged — until then, the
+ * user may need to manually place the PNG inside Assets.xcassets/AppIcon.appiconset.
+ *
+ * @fileoverview iOS 18+ dark icon variant
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+const CANVAS = 1024
+
+/**
+ * @param {string} tightMaster - Main tight master, or --dark-master output
+ * @param {string|null} bgColor - Hex color for opaque flatten, or null for transparent
+ * @param {number} paddingPct - Padding per side (0-40)
+ * @param {string} outRoot - Output directory
+ * @returns {Promise<string>} Path to DefaultIcon-Dark.png
+ */
+export async function genIosDark(tightMaster, bgColor, paddingPct, outRoot) {
+  fs.mkdirSync(outRoot, { recursive: true })
+
+  const inner = Math.floor((CANVAS * (100 - 2 * paddingPct)) / 100)
+  const outPath = path.join(outRoot, 'DefaultIcon-Dark.png')
+
+  const resized = await sharp(tightMaster)
+    .resize({
+      width: inner,
+      height: inner,
+      fit: 'inside',
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    })
+    .toBuffer()
+
+  const pipeline = sharp({
+    create: {
+      width: CANVAS,
+      height: CANVAS,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    }
+  }).composite([{ input: resized, gravity: 'center' }])
+
+  if (bgColor) {
+    // Opaque variant: flatten on dark tint, strip alpha entirely.
+    await pipeline
+      .flatten({ background: bgColor })
+      .removeAlpha()
+      .png({ compressionLevel: 9 })
+      .toFile(outPath)
+  } else {
+    // Apple-recommended default: preserve alpha. System paints its own dark gradient.
+    await pipeline.png({ compressionLevel: 9 }).toFile(outPath)
+  }
+
+  return outPath
+}

package/src/core/branding/gen-ios-tinted.js

@@ -0,0 +1,55 @@
+/**
+ * PurgeTSS - gen-ios-tinted
+ *
+ * Produces Titanium's iOS 18+ tinted root icon:
+ *
+ *   DefaultIcon-Tinted.png   1024×1024, grayscale flattened on black
+ *
+ * Per Apple HIG (iOS 18+): the tinted variant must be a fully opaque grayscale
+ * image over a BLACK (#000000) background. iOS composites its own gradient
+ * background and accent color on top of the grayscale luminance at runtime.
+ *
+ * @fileoverview iOS 18+ tinted icon variant
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+const CANVAS = 1024
+
+export async function genIosTinted(tightMaster, paddingPct, outRoot) {
+  fs.mkdirSync(outRoot, { recursive: true })
+
+  const inner = Math.floor((CANVAS * (100 - 2 * paddingPct)) / 100)
+  const outPath = path.join(outRoot, 'DefaultIcon-Tinted.png')
+
+  // Grayscale the master while keeping alpha — iOS needs luminance info,
+  // not color, to apply the system accent tint at runtime.
+  const resized = await sharp(tightMaster)
+    .grayscale()
+    .resize({
+      width: inner,
+      height: inner,
+      fit: 'inside',
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    })
+    .toBuffer()
+
+  await sharp({
+    create: {
+      width: CANVAS,
+      height: CANVAS,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    }
+  })
+    .composite([{ input: resized, gravity: 'center' }])
+    .flatten({ background: '#000000' })
+    .removeAlpha()
+    .png({ compressionLevel: 9 })
+    .toFile(outPath)
+
+  return outPath
+}

package/src/core/branding/gen-ios.js

@@ -0,0 +1,69 @@
+/**
+ * PurgeTSS - gen-ios
+ *
+ * Produces Titanium's two root-level iOS/Android icons:
+ *
+ *   DefaultIcon.png       1024×1024, alpha preserved (universal fallback)
+ *   DefaultIcon-ios.png   1024×1024, alpha flattened on bg-color (iOS)
+ *
+ * Two distinct paddings — `DefaultIcon.png` is the universal fallback (iOS +
+ * Android when no adaptive icons exist), so it uses the Android safe-zone
+ * padding to stay inside launcher masks. `DefaultIcon-ios.png` is iOS-only
+ * (no launcher mask), so it uses the looser aesthetic iOS padding.
+ *
+ * Apple rejects alpha on App Store icon uploads, so DefaultIcon-ios.png is
+ * always flattened onto the bg-color.
+ *
+ * @fileoverview Root iOS icons for Titanium projects
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+const CANVAS = 1024
+
+export async function genIos(tightMaster, bgColor, androidPadding, iosPadding, outRoot) {
+  fs.mkdirSync(outRoot, { recursive: true })
+
+  const defaultIconPath = path.join(outRoot, 'DefaultIcon.png')
+  const defaultIconIosPath = path.join(outRoot, 'DefaultIcon-ios.png')
+
+  // DefaultIcon.png — alpha preserved, Android safe-zone padding so it stays
+  // launcher-mask-safe when Android falls back to it.
+  await renderSquare(tightMaster, androidPadding, null, defaultIconPath)
+
+  // DefaultIcon-ios.png — flattened on bg-color, iOS aesthetic padding.
+  await renderSquare(tightMaster, iosPadding, bgColor, defaultIconIosPath)
+
+  return { defaultIcon: defaultIconPath, defaultIconIos: defaultIconIosPath }
+}
+
+async function renderSquare(tightMaster, paddingPct, flattenBg, outPath) {
+  const inner = Math.floor((CANVAS * (100 - 2 * paddingPct)) / 100)
+
+  const resized = await sharp(tightMaster)
+    .resize({
+      width: inner,
+      height: inner,
+      fit: 'inside',
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    })
+    .toBuffer()
+
+  const pipeline = sharp({
+    create: {
+      width: CANVAS,
+      height: CANVAS,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    }
+  }).composite([{ input: resized, gravity: 'center' }])
+
+  if (flattenBg) {
+    await pipeline.flatten({ background: flattenBg }).removeAlpha().png({ compressionLevel: 9 }).toFile(outPath)
+  } else {
+    await pipeline.png({ compressionLevel: 9 }).toFile(outPath)
+  }
+}

package/src/core/branding/gen-marketplace.js

@@ -0,0 +1,71 @@
+/**
+ * PurgeTSS - gen-marketplace
+ *
+ * Store-submission artwork:
+ *
+ *   iTunesConnect.png      1024×1024 (App Store)
+ *   MarketplaceArtwork.png 512×512   (Google Play)
+ *
+ * Alpha handling depends on whether --bg-color was explicitly provided:
+ *   - not provided → alpha preserved (matches `ti create` default template)
+ *   - provided     → alpha flattened onto bg-color (safer for dark-mode stores)
+ *
+ * @fileoverview Marketplace artwork for Titanium branding
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+export async function genMarketplace(tightMaster, paddingPct, outRoot, opts = {}) {
+  const { flatten = false, bgColor = '#FFFFFF' } = opts
+  fs.mkdirSync(outRoot, { recursive: true })
+
+  const itunesConnect = await renderSquare(
+    tightMaster,
+    paddingPct,
+    1024,
+    path.join(outRoot, 'iTunesConnect.png'),
+    { flatten, bgColor }
+  )
+  const marketplaceArtwork = await renderSquare(
+    tightMaster,
+    paddingPct,
+    512,
+    path.join(outRoot, 'MarketplaceArtwork.png'),
+    { flatten, bgColor }
+  )
+
+  return { itunesConnect, marketplaceArtwork }
+}
+
+async function renderSquare(tight, paddingPct, canvasSize, outPath, { flatten, bgColor }) {
+  const inner = Math.floor((canvasSize * (100 - 2 * paddingPct)) / 100)
+
+  const resized = await sharp(tight)
+    .resize({
+      width: inner,
+      height: inner,
+      fit: 'inside',
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    })
+    .toBuffer()
+
+  let pipeline = sharp({
+    create: {
+      width: canvasSize,
+      height: canvasSize,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 }
+    }
+  })
+    .composite([{ input: resized, gravity: 'center' }])
+
+  if (flatten) {
+    pipeline = pipeline.flatten({ background: bgColor }).removeAlpha()
+  }
+
+  await pipeline.png({ compressionLevel: 9 }).toFile(outPath)
+  return outPath
+}

package/src/core/branding/gen-notification.js

@@ -0,0 +1,76 @@
+/**
+ * PurgeTSS - gen-notification
+ *
+ * White-on-transparent notification icons × 5 densities.
+ *
+ * Android status bar applies runtime tint based on the notification's color
+ * property, so all non-transparent pixels become white. Color info is discarded.
+ *
+ * Sizes: mdpi=24, hdpi=36, xhdpi=48, xxhdpi=72, xxxhdpi=96.
+ * Output path: drawable-<density>/ic_stat_notify.png
+ *
+ * Notification icons are NOT masked by the launcher, so they render as drawn.
+ * Trim any transparent padding in the master first, then scale the logo to
+ * fill the canvas edge-to-edge with a 1px anti-aliasing margin per side.
+ *
+ * @fileoverview Status-bar notification icons × 5 densities
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+export const NOTIFICATION_DENSITIES = [
+  { name: 'mdpi', size: 24 },
+  { name: 'hdpi', size: 36 },
+  { name: 'xhdpi', size: 48 },
+  { name: 'xxhdpi', size: 72 },
+  { name: 'xxxhdpi', size: 96 }
+]
+
+const EDGE_MARGIN = 2
+
+export async function genNotification(tightMaster, resRoot) {
+  const generated = []
+
+  const trimmedMaster = await sharp(tightMaster)
+    .trim()
+    .png()
+    .toBuffer()
+
+  for (const { name, size } of NOTIFICATION_DENSITIES) {
+    const inner = Math.max(1, size - EDGE_MARGIN)
+    const dir = path.join(resRoot, `drawable-${name}`)
+    fs.mkdirSync(dir, { recursive: true })
+
+    const outPath = path.join(dir, 'ic_stat_notify.png')
+
+    const whitened = await sharp(trimmedMaster)
+      .resize({
+        width: inner,
+        height: inner,
+        fit: 'inside',
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      })
+      .ensureAlpha()
+      .linear([0, 0, 0, 1], [255, 255, 255, 0])
+      .toBuffer()
+
+    await sharp({
+      create: {
+        width: size,
+        height: size,
+        channels: 4,
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      }
+    })
+      .composite([{ input: whitened, gravity: 'center' }])
+      .png({ compressionLevel: 9 })
+      .toFile(outPath)
+
+    generated.push(outPath)
+  }
+
+  return generated
+}

package/src/core/branding/gen-splash.js

@@ -0,0 +1,64 @@
+/**
+ * PurgeTSS - gen-splash
+ *
+ * Android 12+ SplashScreen API icon × 5 densities.
+ *
+ * Spec: 288dp canvas, icon occupies central 192dp (~67% of canvas).
+ * The OS applies a circular mask automatically — keep pixels transparent
+ * outside the 192dp safe-zone.
+ *
+ * Densities: mdpi=288, hdpi=432, xhdpi=576, xxhdpi=864, xxxhdpi=1152.
+ * Output path: drawable-<density>/splash_icon.png
+ *
+ * @fileoverview Android 12+ splash icons × 5 densities
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+export const SPLASH_DENSITIES = [
+  { name: 'mdpi', size: 288 },
+  { name: 'hdpi', size: 432 },
+  { name: 'xhdpi', size: 576 },
+  { name: 'xxhdpi', size: 864 },
+  { name: 'xxxhdpi', size: 1152 }
+]
+
+export async function genSplash(tightMaster, resRoot) {
+  const generated = []
+
+  for (const { name, size } of SPLASH_DENSITIES) {
+    const inner = Math.floor((size * 192) / 288)
+    const dir = path.join(resRoot, `drawable-${name}`)
+    fs.mkdirSync(dir, { recursive: true })
+
+    const outPath = path.join(dir, 'splash_icon.png')
+
+    const innerLogo = await sharp(tightMaster)
+      .resize({
+        width: inner,
+        height: inner,
+        fit: 'inside',
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      })
+      .toBuffer()
+
+    await sharp({
+      create: {
+        width: size,
+        height: size,
+        channels: 4,
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      }
+    })
+      .composite([{ input: innerLogo, gravity: 'center' }])
+      .png({ compressionLevel: 9 })
+      .toFile(outPath)
+
+    generated.push(outPath)
+  }
+
+  return generated
+}