purgetss 7.5.2 → 7.6.1

package/src/shared/constants.js

@@ -29,6 +29,7 @@ export const projectsAppTSS = `${cwd}/app/styles/app.tss`
 export const projects_AppTSS = `${cwd}/app/styles/_app.tss`
 export const projectsAlloyJMKFile = `${cwd}/app/alloy.jmk`
 export const projectsFontsFolder = `${cwd}/app/assets/fonts`
+export const projectsSemanticColorsJSON = `${cwd}/app/assets/semantic.colors.json`
 export const projectsFontAwesomeJS = `${cwd}/app/lib/fontawesome.js`
 
 // ============================================================================
@@ -39,6 +40,8 @@ export const projectsPurgeTSSFolder = `${cwd}/purgetss`
 export const projectsConfigJS = `${cwd}/purgetss/config.cjs`
 export const projectsTailwind_TSS = `${cwd}/purgetss/styles/utilities.tss`
 export const projectsPurge_TSS_Fonts_Folder = `${cwd}/purgetss/fonts`
+export const projectsPurge_TSS_Brand_Folder = `${cwd}/purgetss/brand`
+export const projectsPurge_TSS_Images_Folder = `${cwd}/purgetss/images`
 export const projectsPurge_TSS_Styles_Folder = `${cwd}/purgetss/styles`
 export const projectsFA_TSS_File = `${cwd}/purgetss/styles/fontawesome.tss`
 

package/src/shared/helpers/typography.js

@@ -26,18 +26,53 @@ function removeFractions(modifiersAndValues, extras = []) {
 
 /**
  * Font family property for text components
+ *
+ * Built-in platform defaults:
+ *   - font-sans → Android: 'sans-serif', iOS: 'Helvetica Neue'
+ *   - font-serif → Android: 'serif', iOS: 'Georgia'
+ *   - font-mono → 'monospace' (both platforms)
+ *
+ * User values from config.cjs override defaults cross-platform.
+ *
  * @param {Object} modifiersAndValues - Modifier and value pairs
  * @returns {string} Generated styles
  */
 export function fontFamily(modifiersAndValues) {
+  const platformDefaults = {
+    sans: { ios: 'Helvetica Neue', android: 'sans-serif' },
+    serif: { ios: 'Georgia', android: 'serif' }
+  }
+
+  const crossPlatformDefaults = { mono: 'monospace' }
+
+  const defaults = { ...modifiersAndValues }
+  const ios = {}
+  const android = {}
+
+  _.each(crossPlatformDefaults, (value, key) => {
+    if (!(key in defaults)) {
+      defaults[key] = value
+    }
+  })
+
+  _.each(platformDefaults, (platforms, key) => {
+    if (!(key in defaults)) {
+      ios[key] = platforms.ios
+      android[key] = platforms.android
+    }
+  })
+
+  const selectorsAndValues = {}
+  if (!_.isEmpty(defaults)) selectorsAndValues.default = defaults
+  if (!_.isEmpty(ios)) selectorsAndValues.ios = ios
+  if (!_.isEmpty(android)) selectorsAndValues.android = android
+
   return processProperties({
     prop: 'fontFamily',
     modules: 'Ti.UI.ActivityIndicator, Ti.UI.Button, Ti.UI.Label, Ti.UI.ListItem, Ti.UI.Picker, Ti.UI.PickerColumn, Ti.UI.PickerRow, Ti.UI.ProgressBar, Ti.UI.Switch, Ti.UI.TableViewRow, Ti.UI.TextArea, Ti.UI.TextField'
   }, {
     font: '{ font: { fontFamily: {value} } }'
-  }, {
-    default: modifiersAndValues
-  })
+  }, selectorsAndValues)
 }
 
 /**

package/src/shared/logger.js

@@ -19,6 +19,27 @@ const purgeLabel = colores.purgeLabel
 // Debug mode flag (can be set externally)
 let purgingDebug = false
 
+// Section mode: when active, the first info/warn/error/file call acts as a
+// ::PurgeTSS:: header and every subsequent call prints indented 3 spaces
+// without the prefix. Used by long-running flows (e.g. purge) that want a
+// single signed line per run instead of one per step. Always wrap with
+// try/finally in the caller to guarantee endSection() runs.
+let _sectionMode = false
+let _sectionHeaderEmitted = false
+
+function _emit(text) {
+  if (_sectionMode) {
+    if (_sectionHeaderEmitted) {
+      console.log('   ' + text)
+    } else {
+      console.log(purgeLabel, text)
+      _sectionHeaderEmitted = true
+    }
+  } else {
+    console.log(purgeLabel, text)
+  }
+}
+
 /**
  * Main logger object with different log levels
  * Maintains exact same API as original for compatibility
@@ -29,7 +50,7 @@ export const logger = {
    * @param {...any} args - Arguments to log
    */
   info: function(...args) {
-    console.log(purgeLabel, args.join(' '))
+    _emit(args.join(' '))
   },
 
   /**
@@ -37,7 +58,7 @@ export const logger = {
    * @param {...any} args - Arguments to log
    */
   warn: function(...args) {
-    console.log(purgeLabel, chalk.yellow(args.join(' ')))
+    _emit(chalk.yellow(args.join(' ')))
   },
 
   /**
@@ -45,7 +66,7 @@ export const logger = {
    * @param {...any} args - Arguments to log
    */
   error: function(...args) {
-    console.log(purgeLabel, chalk.red(args.join(' ')))
+    _emit(chalk.red(args.join(' ')))
   },
 
   /**
@@ -53,7 +74,51 @@ export const logger = {
    * @param {...any} args - Arguments to log
    */
   file: function(...args) {
-    console.log(purgeLabel, chalk.yellow(args.join(' ')), 'file created!')
+    _emit(chalk.yellow(args.join(' ')) + ' file created!')
+  },
+
+  /**
+   * Enable section mode. The next info/warn/error/file call becomes the
+   * ::PurgeTSS:: header; subsequent calls print indented without prefix.
+   * MUST be paired with endSection() via try/finally to avoid state leaks.
+   */
+  startSection: function() {
+    _sectionMode = true
+    _sectionHeaderEmitted = false
+  },
+
+  /**
+   * Exit section mode. Safe to call even if section wasn't started.
+   */
+  endSection: function() {
+    _sectionMode = false
+    _sectionHeaderEmitted = false
+  },
+
+  /**
+   * Log a multi-line block with a single ::PurgeTSS:: header.
+   * First arg is the header (printed next to purgeLabel); remaining args are
+   * continuation lines indented 3 spaces. Pass '' for a blank separator line.
+   *
+   * @param {string} header - Header line (printed after purgeLabel)
+   * @param {...string} lines - Continuation lines (indented, or '' for blank)
+   */
+  block: function(header, ...lines) {
+    console.log(purgeLabel, header)
+    for (const line of lines) {
+      console.log(line === '' ? '' : '   ' + line)
+    }
+  },
+
+  /**
+   * Log a sub-line without the ::PurgeTSS:: prefix, indented 3 spaces.
+   * Use inside sequential flows where a prior logger.info emitted the header.
+   * Prints synchronously, preserving timing with logger.info.
+   *
+   * @param {...any} args - Arguments to log
+   */
+  item: function(...args) {
+    console.log('   ' + args.join(' '))
   }
 }
 

package/src/shared/prompt.js

@@ -0,0 +1,64 @@
+/**
+ * PurgeTSS - Interactive prompt helpers
+ *
+ * Small wrapper around Node's readline for yes/no confirmations on destructive
+ * operations (in-place brand/images writes). Auto-skips when:
+ *   - the caller sets `yes: true` (e.g. from --yes flag)
+ *   - the PURGETSS_YES=1 environment variable is set
+ *   - stdin is not a TTY (CI, hooks, piped input)
+ *
+ * Default answer is NO on empty input — requires explicit "y" / "yes" to proceed.
+ *
+ * @fileoverview TTY-aware confirmation prompts
+ * @author César Estrada
+ */
+
+import readline from 'node:readline/promises'
+
+/**
+ * Ask the user for a yes/no confirmation.
+ *
+ * @param {string} message - Prompt text shown to the user. A trailing space is
+ *   added automatically, so pass something like "Continue? [y/N]".
+ * @param {Object} [opts]
+ * @param {boolean} [opts.yes=false] - Skip prompt and answer yes (e.g. --yes flag).
+ * @returns {Promise<boolean>} True when confirmed or skipped; false otherwise.
+ */
+export async function confirm(message, { yes = false } = {}) {
+  if (yes) return true
+  if (process.env.PURGETSS_YES === '1') return true
+  if (!process.stdin.isTTY) return true
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    const answer = await rl.question(`${message} `)
+    return /^y(es)?$/i.test(answer.trim())
+  } finally {
+    rl.close()
+  }
+}
+
+/**
+ * Three-way confirmation: yes / no / always. Same skip rules as confirm()
+ * (--yes flag, PURGETSS_YES env, non-TTY all resolve to 'yes').
+ *
+ * @param {string} message - Prompt text (a trailing space is added).
+ * @param {Object} [opts]
+ * @param {boolean} [opts.yes=false] - Skip prompt, answer 'yes'.
+ * @returns {Promise<'yes'|'no'|'always'>} The user's choice.
+ */
+export async function confirmWithAlways(message, { yes = false } = {}) {
+  if (yes) return 'yes'
+  if (process.env.PURGETSS_YES === '1') return 'yes'
+  if (!process.stdin.isTTY) return 'yes'
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    const answer = (await rl.question(`${message} `)).trim().toLowerCase()
+    if (answer === 'a' || answer === 'always') return 'always'
+    if (answer === 'y' || answer === 'yes') return 'yes'
+    return 'no'
+  } finally {
+    rl.close()
+  }
+}

package/src/shared/svg-utils.js

@@ -0,0 +1,80 @@
+/**
+ * PurgeTSS - Shared SVG/Sharp utilities
+ *
+ * Centralizes the logic for safely rasterizing SVGs with Sharp — specifically,
+ * handling SVGs that come out of vector editors (Affinity, Illustrator) with
+ * absurdly large viewBoxes that would otherwise trigger Sharp's pixel limit.
+ *
+ * Shared by:
+ *   - src/core/branding/prepare-master.js (brand pipeline)
+ *   - src/core/images/gen-scales.js       (images pipeline)
+ *
+ * @fileoverview SVG rasterization helpers for the Sharp pipeline
+ * @author César Estrada
+ */
+
+import fs from 'fs'
+import path from 'path'
+import sharp from 'sharp'
+
+// SVGs with natural dimensions above this (in points) are almost always the
+// result of a vector editor baking in transforms — e.g. Affinity exporting a
+// "pliego" as 29559×13542 pt. Callers compensate with adaptive density; this
+// threshold only controls the user-facing warning.
+export const VIEWBOX_WARN_THRESHOLD = 4096
+
+/**
+ * Compute a Sharp density (DPI) so that rasterization of an SVG lands at
+ * approximately `targetSupersampledMax` pixels on the longest side, regardless
+ * of the SVG's intrinsic viewBox. Clamped to Sharp's valid range (1..2400).
+ *
+ * @param {number} naturalMax - Largest SVG dimension in points (at 72 DPI).
+ * @param {number} targetSupersampledMax - Desired raster size on the longest side.
+ * @returns {number} A safe density value in [1, 2400].
+ */
+export function computeSvgDensity(naturalMax, targetSupersampledMax) {
+  return Math.min(
+    2400,
+    Math.max(1, Math.round((targetSupersampledMax / naturalMax) * 72))
+  )
+}
+
+/**
+ * Read an SVG safely — buffer + metadata with the pixel-limit check disabled
+ * (Sharp enforces it even during header parsing for SVG inputs). Optionally
+ * emits a warning via the provided logger when the viewBox is disproportionate.
+ *
+ * The caller is responsible for computing a bounded density (via
+ * computeSvgDensity) before actually rendering — this keeps the real pixel
+ * output inside Sharp's limit even though the limit was disabled at read time.
+ *
+ * @param {string} svgPath - Absolute path to the SVG file.
+ * @param {Object} [opts]
+ * @param {Object} [opts.logger] - Logger exposing a .warning(msg) method. If
+ *   omitted, no warning is emitted (silent mode, for unit tests).
+ * @param {boolean} [opts.withAdvice=false] - Include the "re-export" advice
+ *   line. Enable for the brand pipeline (where the logo is central); keep
+ *   false for the images pipeline (which may process many files).
+ * @returns {Promise<{buffer: Buffer, meta: Object, naturalMax: number}>}
+ */
+export async function readSvgSafely(svgPath, { logger, withAdvice = false } = {}) {
+  const buffer = fs.readFileSync(svgPath)
+  const meta = await sharp(buffer, { limitInputPixels: false }).metadata()
+  const naturalMax = Math.max(meta.width, meta.height)
+
+  if (logger && naturalMax > VIEWBOX_WARN_THRESHOLD) {
+    logger.warning(
+      `⚠  ${path.basename(svgPath)} has a disproportionate viewBox (${meta.width}×${meta.height} pt).`
+    )
+    if (withAdvice) {
+      logger.warning(
+        `   Re-export from your vector editor with a canvas-sized viewBox if possible.`
+      )
+    }
+    logger.warning(
+      `   Adapting rasterization density to compensate.`
+    )
+  }
+
+  return { buffer, meta, naturalMax }
+}

package/src/shared/utils.js

@@ -73,8 +73,10 @@ export function alloyProject(silent = false) {
 
   if (!fs.existsSync(`${cwd}/app/views`)) {
     if (!silent) {
-      logger.info(`Please make sure you are running ${chalk.green('purgetss')} within an Alloy Project.`)
-      logger.info(`For more information, visit ${chalk.green('https://purgetss.com')}`)
+      logger.block(
+        `Please make sure you are running ${chalk.green('purgetss')} within an Alloy Project.`,
+        `For more information, visit ${chalk.green('https://purgetss.com')}`
+      )
     }
     return false
   }
@@ -93,8 +95,10 @@ export function classicProject(silent = false) {
 
   if (!fs.existsSync(`${cwd}/Resources`)) {
     if (!silent) {
-      logger.info(`Please make sure you are running ${chalk.green('purgetss')} within a Titanium's Classic Project.`)
-      logger.info(`For more information, visit ${chalk.green('https://purgetss.com')}`)
+      logger.block(
+        `Please make sure you are running ${chalk.green('purgetss')} within a Titanium's Classic Project.`,
+        `For more information, visit ${chalk.green('https://purgetss.com')}`
+      )
     }
     return false
   }