purgetss 7.9.0 → 7.11.1

package/src/shared/helpers/colors.js

@@ -1,5 +1,5 @@
 import _ from 'lodash'
-import { processProperties, processComments, parseValue, setModifier2, removeLastDash, addTransparencyToValue } from './utils.js'
+import { processProperties, processComments, parseValue, setModifier2, removeLastDash, addTransparencyToValue, defaultModifier, camelCaseToDash } from './utils.js'
 /**
  * Active tint color for tabs
  * @param {Object} modifiersAndValues - Modifier and value pairs
@@ -646,9 +646,20 @@ export function backgroundGradient(modifiersAndValues) {
   _.each(objectPosition, (properties, rule) => {
     _.each(modifiersAndValues, (value, modifier) => {
       if (typeof value === 'object') {
-        _.each(value, (_value, _modifier) => {
-          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}`)}': ` + _.replace(_.replace(properties, /{transparentValue}/g, `${addTransparencyToValue(parseValue(_value))}`), /{value}/g, parseValue(_value)) + '\n'
-        })
+        const emitLeaf = (leafValue, _modifier, suffix) => {
+          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}${suffix}`)}': ` + _.replace(_.replace(properties, /{transparentValue}/g, `${addTransparencyToValue(parseValue(leafValue))}`), /{value}/g, parseValue(leafValue)) + '\n'
+        }
+        const walk = (val, _modifier, suffix) => {
+          if (val && typeof val === 'object') {
+            _.each(val, (childVal, childKey) => {
+              const newSuffix = defaultModifier(childKey) ? suffix : `${suffix}-${camelCaseToDash(String(childKey))}`
+              walk(childVal, _modifier, newSuffix)
+            })
+          } else {
+            emitLeaf(val, _modifier, suffix)
+          }
+        }
+        _.each(value, (_value, _modifier) => walk(_value, _modifier, ''))
       } else {
         convertedStyles += `'.${setModifier2(rule, modifier)}${setModifier2(modifier)}': ` + _.replace(_.replace(properties, /{value}/g, parseValue(value)), /{transparentValue}/g, `${addTransparencyToValue(parseValue(value))}`) + '\n'
       }
@@ -665,9 +676,20 @@ export function backgroundGradient(modifiersAndValues) {
   _.each(objectPosition, (properties, rule) => {
     _.each(modifiersAndValues, (value, modifier) => {
       if (typeof value === 'object') {
-        _.each(value, (_value, _modifier) => {
-          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}`)}': ` + _.replace(properties, /{value}/g, parseValue(_value)) + '\n'
-        })
+        const emitLeaf = (leafValue, _modifier, suffix) => {
+          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}${suffix}`)}': ` + _.replace(properties, /{value}/g, parseValue(leafValue)) + '\n'
+        }
+        const walk = (val, _modifier, suffix) => {
+          if (val && typeof val === 'object') {
+            _.each(val, (childVal, childKey) => {
+              const newSuffix = defaultModifier(childKey) ? suffix : `${suffix}-${camelCaseToDash(String(childKey))}`
+              walk(childVal, _modifier, newSuffix)
+            })
+          } else {
+            emitLeaf(val, _modifier, suffix)
+          }
+        }
+        _.each(value, (_value, _modifier) => walk(_value, _modifier, ''))
       } else {
         convertedStyles += `'.${setModifier2(rule, modifier)}${setModifier2(modifier)}': ` + _.replace(properties, /{value}/g, parseValue(value)) + '\n'
       }
@@ -688,9 +710,20 @@ export function backgroundSelectedGradient(modifiersAndValues) {
   _.each(objectPosition, (properties, rule) => {
     _.each(modifiersAndValues, (value, modifier) => {
       if (typeof value === 'object') {
-        _.each(value, (_value, _modifier) => {
-          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}`)}': ` + _.replace(_.replace(properties, /{transparentValue}/g, `${addTransparencyToValue(parseValue(_value))}`), /{value}/g, parseValue(_value)) + '\n'
-        })
+        const emitLeaf = (leafValue, _modifier, suffix) => {
+          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}${suffix}`)}': ` + _.replace(_.replace(properties, /{transparentValue}/g, `${addTransparencyToValue(parseValue(leafValue))}`), /{value}/g, parseValue(leafValue)) + '\n'
+        }
+        const walk = (val, _modifier, suffix) => {
+          if (val && typeof val === 'object') {
+            _.each(val, (childVal, childKey) => {
+              const newSuffix = defaultModifier(childKey) ? suffix : `${suffix}-${camelCaseToDash(String(childKey))}`
+              walk(childVal, _modifier, newSuffix)
+            })
+          } else {
+            emitLeaf(val, _modifier, suffix)
+          }
+        }
+        _.each(value, (_value, _modifier) => walk(_value, _modifier, ''))
       } else {
         convertedStyles += `'.${setModifier2(rule, modifier)}${setModifier2(modifier)}': ` + _.replace(_.replace(properties, /{value}/g, parseValue(value)), /{transparentValue}/g, `${addTransparencyToValue(parseValue(value))}`) + '\n'
       }
@@ -707,9 +740,20 @@ export function backgroundSelectedGradient(modifiersAndValues) {
   _.each(objectPosition, (properties, rule) => {
     _.each(modifiersAndValues, (value, modifier) => {
       if (typeof value === 'object') {
-        _.each(value, (_value, _modifier) => {
-          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}`)}': ` + _.replace(properties, /{value}/g, parseValue(_value)) + '\n'
-        })
+        const emitLeaf = (leafValue, _modifier, suffix) => {
+          convertedStyles += `'.${removeLastDash(`${rule}-${setModifier2(modifier, rule)}${setModifier2(_modifier)}${suffix}`)}': ` + _.replace(properties, /{value}/g, parseValue(leafValue)) + '\n'
+        }
+        const walk = (val, _modifier, suffix) => {
+          if (val && typeof val === 'object') {
+            _.each(val, (childVal, childKey) => {
+              const newSuffix = defaultModifier(childKey) ? suffix : `${suffix}-${camelCaseToDash(String(childKey))}`
+              walk(childVal, _modifier, newSuffix)
+            })
+          } else {
+            emitLeaf(val, _modifier, suffix)
+          }
+        }
+        _.each(value, (_value, _modifier) => walk(_value, _modifier, ''))
       } else {
         convertedStyles += `'.${setModifier2(rule, modifier)}${setModifier2(modifier)}': ` + _.replace(properties, /{value}/g, parseValue(value)) + '\n'
       }

package/src/shared/helpers/utils.js

@@ -1,6 +1,13 @@
 import fs from 'fs'
 import _ from 'lodash'
 import { deriveAlphaKey } from '../semantic-helpers.js'
+import {
+  projectsFA_TSS_File,
+  srcFontAwesomeTSSFile,
+  srcMaterialIconsTSSFile,
+  srcMaterialSymbolsTSSFile,
+  srcFramework7FontTSSFile
+} from '../constants.js'
 
 // Internal variables and constants
 const _applyClasses = {}
@@ -30,14 +37,25 @@ export function processProperties(info, selectorAndDeclarationBlock, selectorsAn
       _.each(rulesAndValuesPair, (value, rule) => {
         if (debug) console.log('rule:', rule, 'value:', value)
         if (typeof value === 'object') {
-          _.each(value, (_value, key) => {
-            if (debug) console.log('key:', key, '_value:', _value)
-            let processedProperties = _.replace(declarationBlock, /{value}/g, parseValue(_value, minusSigns))
+          const emitLeaf = (leafValue, key, suffix) => {
+            if (debug) console.log('key:', key, 'leafValue:', leafValue, 'suffix:', suffix)
+            let processedProperties = _.replace(declarationBlock, /{value}/g, parseValue(leafValue, minusSigns))
             if (declarationBlock.includes('double')) {
-              processedProperties = _.replace(processedProperties, /{double}/g, parseValue(_value, minusSigns) * 2)
+              processedProperties = _.replace(processedProperties, /{double}/g, parseValue(leafValue, minusSigns) * 2)
             }
-            convertedStyles += defaultModifier(key) ? `'.${setModifier2(mainSelector, rule)}${setModifier2(rule)}${setModifier2(selector)}': ${processedProperties}\n` : `'.${setModifier2(mainSelector, rule)}${setModifier2(rule, key)}${setModifier2(key)}${setModifier2(selector)}': ${processedProperties}\n`
-          })
+            convertedStyles += defaultModifier(key) ? `'.${setModifier2(mainSelector, rule)}${setModifier2(rule)}${suffix}${setModifier2(selector)}': ${processedProperties}\n` : `'.${setModifier2(mainSelector, rule)}${setModifier2(rule, key)}${setModifier2(key)}${suffix}${setModifier2(selector)}': ${processedProperties}\n`
+          }
+          const walk = (val, key, suffix) => {
+            if (val && typeof val === 'object') {
+              _.each(val, (childVal, childKey) => {
+                const newSuffix = defaultModifier(childKey) ? suffix : `${suffix}-${camelCaseToDash(String(childKey))}`
+                walk(childVal, key, newSuffix)
+              })
+            } else {
+              emitLeaf(val, key, suffix)
+            }
+          }
+          _.each(value, (_value, key) => walk(_value, key, ''))
         } else {
           let processedProperties = _.replace(declarationBlock, /{value}/g, parseValue(value, minusSigns))
           if (declarationBlock.includes('double')) {
@@ -464,6 +482,18 @@ export function compileApplyDirectives(twClasses) {
   const twClassesArray = twClasses.split(/\r?\n/)
   const fontsClassesArray = (fs.existsSync(cwd + '/purgetss/styles/fonts.tss')) ? fs.readFileSync(cwd + '/purgetss/styles/fonts.tss', 'utf8').split(/\r?\n/) : null
 
+  // Default icon font sources (FontAwesome, Material Icons/Symbols, Framework7).
+  // Project-level fontawesome.tss (Pro/Beta) takes precedence over the bundled default,
+  // matching the precedence used by purgeFontAwesome().
+  const iconClassesArrays = [
+    fs.existsSync(projectsFA_TSS_File) ? projectsFA_TSS_File : srcFontAwesomeTSSFile,
+    srcMaterialIconsTSSFile,
+    srcMaterialSymbolsTSSFile,
+    srcFramework7FontTSSFile
+  ]
+    .filter(p => fs.existsSync(p))
+    .map(p => fs.readFileSync(p, 'utf8').split(/\r?\n/))
+
   _.each(_applyClasses, (values, className) => {
     const indexOfModifier = findIndexOfClassName(`'${className}':`, twClassesArray)
 
@@ -519,6 +549,14 @@ export function compileApplyDirectives(twClasses) {
             if (!foundClass && fontsClassesArray) {
               foundClass = fontsClassesArray[findIndexOfClassName(genericClassName, fontsClassesArray)]
             }
+            // Last resort: search default icon font sources (FontAwesome, Material Icons/Symbols, Framework7)
+            // so apply: directives can use fas, fa-*, mi-*, ms-*, f7-* without requiring fonts.tss
+            if (!foundClass) {
+              for (const arr of iconClassesArrays) {
+                const idx = findIndexOfClassName(genericClassName, arr)
+                if (idx !== -1) { foundClass = arr[idx]; break }
+              }
+            }
           }
 
           if (foundClass) compoundClasses.push(justProperties(foundClass))
@@ -607,8 +645,8 @@ function deduplicateLineProperties(line) {
   let depth = 0
   let current = ''
   for (const char of propsStr) {
-    if (char === '{') depth++
-    else if (char === '}') depth--
+    if (char === '{' || char === '[') depth++
+    else if (char === '}' || char === ']') depth--
     else if (char === ',' && depth === 0) {
       if (current.trim()) props.push(current.trim())
       current = ''

package/src/shared/logger.js

@@ -77,6 +77,14 @@ export const logger = {
     _emit(chalk.yellow(args.join(' ')) + ' file created!')
   },
 
+  /**
+   * Log success messages in green
+   * @param {...any} args - Arguments to log
+   */
+  success: function(...args) {
+    _emit(chalk.green(args.join(' ')))
+  },
+
   /**
    * Enable section mode. The next info/warn/error/file call becomes the
    * ::PurgeTSS:: header; subsequent calls print indented without prefix.
@@ -122,6 +130,10 @@ export const logger = {
   }
 }
 
+// Aliases: long-form `warning` matches the semantic of `warn`. Multiple
+// callsites across branding/images/svg flows expect this name.
+logger.warning = logger.warn
+
 /**
  * Get current debug mode status
  * @returns {boolean} Current debug status

package/src/shared/validation/config-validator.js

@@ -0,0 +1,167 @@
+/**
+ * Config validator for purgetss/config.cjs.
+ *
+ * Validates known fields in the user's config and, on type mismatch, throws an
+ * error formatted via the shared error-reporter so that File / Path / Line /
+ * Context / Issue / Fix are obvious instead of crashing downstream with
+ * cryptic messages like `rule.startsWith is not a function`.
+ *
+ * Currently validates:
+ *   - theme.fontFamily.* and theme.extend.fontFamily.*
+ *       Expected: string. Detects Tailwind-style arrays (`['Inter', 'sans-serif']`)
+ *       and reports with a fix snippet.
+ *
+ * Extend by adding entries to FIELD_RULES below. Each rule names the JSON
+ * path, the expected JS type, and a tip explaining the fix.
+ */
+
+import fs from 'fs'
+import * as acorn from 'acorn'
+import chalk from 'chalk'
+import { throwSyntaxError } from '../error-reporter.js'
+
+// ─── Field rules ────────────────────────────────────────────────────────────
+const FIELD_RULES = [
+  {
+    parent: 'theme.fontFamily',
+    expected: 'string',
+    tipFor: (key, value) => buildFontFamilyTip(key, value)
+  },
+  {
+    parent: 'theme.extend.fontFamily',
+    expected: 'string',
+    tipFor: (key, value) => buildFontFamilyTip(key, value)
+  }
+]
+
+function buildFontFamilyTip(key, value) {
+  if (Array.isArray(value)) {
+    const first = value.length > 0 ? value[0] : 'FontName'
+    return `Use a string instead of an array. Tailwind-style fallback fonts are not supported — Titanium accepts a single font family per element. Change to: ${chalk.green(`${quoteKey(key)}: '${first}'`)}`
+  }
+  return `Expected a string. Change to: ${chalk.green(`${quoteKey(key)}: 'FontName'`)}`
+}
+
+function quoteKey(key) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Validate the loaded config object against FIELD_RULES.
+ * Throws a formatted Error (via error-reporter) on the first mismatch found.
+ *
+ * @param {Object} configObject - The required()'d config object.
+ * @param {string} configPath - Absolute path to the config.cjs file.
+ */
+export function validateConfig(configObject, configPath) {
+  for (const rule of FIELD_RULES) {
+    const parent = getByPath(configObject, rule.parent)
+    if (!parent || typeof parent !== 'object') continue
+
+    for (const key of Object.keys(parent)) {
+      const value = parent[key]
+      if (typeof value === rule.expected) continue
+
+      const jsonPath = `${rule.parent}.${key}`
+      const source = safeReadFile(configPath)
+      const contextLines = source ? source.split('\n') : null
+      const line = contextLines ? findPropertyLine(source, jsonPath) : null
+
+      throwSyntaxError({
+        type: 'Config',
+        file: configPath,
+        path: jsonPath,
+        line,
+        contextLines,
+        issue: `Expected ${rule.expected}, got ${describeType(value)} (${previewValue(value)})`,
+        fix: rule.tipFor(key, value)
+      })
+    }
+  }
+}
+
+// ─── AST scan to find the line where a dotted-path property is declared ─────
+
+function findPropertyLine(source, dottedPath) {
+  let ast
+  try {
+    ast = acorn.parse(source, { ecmaVersion: 'latest', locations: true })
+  } catch (_e) {
+    return null
+  }
+
+  let found = null
+
+  function walk(node, currentPath) {
+    if (found || !node || typeof node !== 'object') return
+
+    if (node.type === 'ObjectExpression') {
+      for (const prop of node.properties) {
+        if (prop.type !== 'Property') continue
+        const keyName = prop.key.name || prop.key.value
+        if (keyName == null) continue
+        const nextPath = currentPath ? `${currentPath}.${keyName}` : keyName
+
+        if (nextPath === dottedPath && prop.loc) {
+          found = prop.loc.start.line
+          return
+        }
+        walk(prop.value, nextPath)
+        if (found) return
+      }
+      return
+    }
+
+    if (node.type === 'AssignmentExpression') {
+      walk(node.right, currentPath)
+      return
+    }
+
+    for (const key of Object.keys(node)) {
+      if (key === 'loc' || key === 'start' || key === 'end' || key === 'range') continue
+      const child = node[key]
+      if (Array.isArray(child)) {
+        for (const c of child) {
+          walk(c, currentPath)
+          if (found) return
+        }
+      } else if (child && typeof child === 'object') {
+        walk(child, currentPath)
+      }
+    }
+  }
+
+  walk(ast, '')
+  return found
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function describeType(value) {
+  if (value === null) return 'null'
+  if (Array.isArray(value)) return 'Array'
+  return typeof value
+}
+
+function previewValue(value) {
+  try {
+    const json = JSON.stringify(value)
+    return json && json.length > 60 ? json.slice(0, 57) + '...' : json
+  } catch (_e) {
+    return String(value)
+  }
+}
+
+function getByPath(obj, dottedPath) {
+  return dottedPath.split('.').reduce((acc, key) => (acc == null ? acc : acc[key]), obj)
+}
+
+function safeReadFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8')
+  } catch (_e) {
+    return null
+  }
+}