purgetss 7.3.1 → 7.5.0

package/src/shared/helpers/animation.js

@@ -243,6 +243,28 @@ export function toggle() {
   return convertedStyles
 }
 
+/**
+ * Snap properties for the Animation module
+ * @returns {string} Generated styles
+ */
+export function snap() {
+  let convertedStyles = processComments({
+    prop: 'snap - For the Animation module',
+    modules: 'Animation'
+  })
+
+  convertedStyles += '\'.snap-back\': { animationProperties: { snap: { back: true } } }\n'
+  convertedStyles += '\'.snap-back-false\': { animationProperties: { snap: { back: false } } }\n'
+  convertedStyles += '\'.snap-center\': { animationProperties: { snap: { center: true } } }\n'
+  convertedStyles += '\'.snap-center-false\': { animationProperties: { snap: { center: false } } }\n'
+  convertedStyles += '\'.snap-magnet\': { animationProperties: { snap: { magnet: true } } }\n'
+  convertedStyles += '\'.snap-magnet-false\': { animationProperties: { snap: { magnet: false } } }\n'
+  convertedStyles += '\'.keep-z-index\': { animationProperties: { keepZIndex: true } }\n'
+  convertedStyles += '\'.keep-z-index-false\': { animationProperties: { keepZIndex: false } }\n'
+
+  return convertedStyles
+}
+
 /**
  * Dragging type property
  * @returns {string} Generated styles

package/src/shared/helpers/utils.js

@@ -374,6 +374,26 @@ export function fixInvalidValues(invalidValues, currentValue) {
   return invalidValues[currentValue] || currentValue
 }
 
+/**
+ * Recursively serialize a value for TSS output.
+ * Handles primitives, plain objects, and arrays of objects.
+ * @param {*} val - Value to serialize
+ * @returns {string} TSS-compatible string representation
+ */
+function serializeValue(val) {
+  if (Array.isArray(val)) {
+    const items = val.map(item => serializeValue(item))
+    return `[ ${items.join(', ')} ]`
+  }
+  if (typeof val === 'object' && val !== null) {
+    const entries = Object.entries(val)
+      .map(([k, v]) => `${k}: ${serializeValue(v)}`)
+      .join(', ')
+    return `{ ${entries} }`
+  }
+  return parseValue(val)
+}
+
 /**
  * Generate custom rules for Titanium styles
  * @param {Object} _value - Value object containing rules
@@ -399,27 +419,7 @@ export function customRules(_value, _key, changeToDash = false) {
 
             customProperties += ' {_applyProperties_},'
           } else {
-            customProperties += ` ${theModifier}: {`
-
-            let extraCustomProperties = ''
-
-            _.each(theValue, (extraValue, extraModifier) => {
-              if (typeof (extraValue) === 'object' && extraValue !== null) {
-                customProperties += ` ${extraModifier}: {`
-
-                let moreExtraCustomProperties = ''
-
-                _.each(extraValue, (moreExtraValue, moreModifier) => {
-                  moreExtraCustomProperties += ` ${moreModifier}: ${parseValue(moreExtraValue)},`
-                })
-
-                customProperties += `${removeLastCharacter(moreExtraCustomProperties)} },`
-              } else {
-                extraCustomProperties += ` ${extraModifier}: ${parseValue(extraValue)},`
-              }
-            })
-
-            customProperties += `${removeLastCharacter(extraCustomProperties)} },`
+            customProperties += ` ${theModifier}: ${serializeValue(theValue)},`
           }
         } else {
           if (theModifier === 'apply') {
@@ -470,6 +470,10 @@ export function compileApplyDirectives(twClasses) {
       const compoundClasses = []
       const classesWithOpacityValues = []
 
+      // Extract platform from the target class (e.g., 'Window[platform=ios]' → 'ios')
+      const platformMatch = className.match(/\[platform=(\w+)\]/)
+      const targetPlatform = platformMatch ? platformMatch[1] : null
+
       _.each([...values], searchClass => {
         if (searchClass.includes('ios:')) {
           searchClass = `${searchClass.replace('ios:', '')}[platform=ios]`
@@ -496,14 +500,27 @@ export function compileApplyDirectives(twClasses) {
 
           classesWithOpacityValues.push({ decimalValue, transparency, originalClass, classNameWithTransparency })
         } else {
-          const className = `'.${searchClass}':`
-          let foundClass = twClassesArray[findIndexOfClassName(className, twClassesArray)]
+          let foundClass = null
+
+          // If the target has a platform, try platform-specific class first
+          if (targetPlatform && !searchClass.includes('[platform=')) {
+            const platformClassName = `'.${searchClass}[platform=${targetPlatform}]':`
+            foundClass = twClassesArray[findIndexOfClassName(platformClassName, twClassesArray)]
+            if (!foundClass && fontsClassesArray) {
+              foundClass = fontsClassesArray[findIndexOfClassName(platformClassName, fontsClassesArray)]
+            }
+          }
 
-          if (foundClass) compoundClasses.push(justProperties(foundClass))
-          else if (fontsClassesArray) {
-            foundClass = fontsClassesArray[findIndexOfClassName(className, fontsClassesArray)]
-            if (foundClass) compoundClasses.push(justProperties(foundClass))
+          // Fall back to generic class (no platform suffix)
+          if (!foundClass) {
+            const genericClassName = `'.${searchClass}':`
+            foundClass = twClassesArray[findIndexOfClassName(genericClassName, twClassesArray)]
+            if (!foundClass && fontsClassesArray) {
+              foundClass = fontsClassesArray[findIndexOfClassName(genericClassName, fontsClassesArray)]
+            }
           }
+
+          if (foundClass) compoundClasses.push(justProperties(foundClass))
         }
       })
 
@@ -522,12 +539,54 @@ export function compileApplyDirectives(twClasses) {
       }
 
       twClassesArray[indexOfModifier] = _.replace(twClassesArray[indexOfModifier], /{_applyProperties_}/, fixDuplicateKeys(compoundClasses).join(', '))
+      twClassesArray[indexOfModifier] = deduplicateLineProperties(twClassesArray[indexOfModifier])
     }
   })
 
   return twClassesArray.join('\n')
 }
 
+/**
+ * Remove duplicate property keys in a TSS line, keeping the last occurrence.
+ * This ensures apply directives override static defaults (e.g. backgroundColor).
+ */
+function deduplicateLineProperties(line) {
+  const match = line.match(/^(.*?\{)\s*(.*)\s*(\})$/)
+  if (!match) return line
+
+  const prefix = match[1]
+  const propsStr = match[2]
+  const suffix = match[3]
+
+  // Split by comma respecting nested braces
+  const props = []
+  let depth = 0
+  let current = ''
+  for (const char of propsStr) {
+    if (char === '{') depth++
+    else if (char === '}') depth--
+    else if (char === ',' && depth === 0) {
+      if (current.trim()) props.push(current.trim())
+      current = ''
+      continue
+    }
+    current += char
+  }
+  if (current.trim()) props.push(current.trim())
+
+  // Keep last occurrence of each key
+  const seen = new Map()
+  props.forEach(prop => {
+    const colonIdx = prop.indexOf(':')
+    if (colonIdx > -1) {
+      const key = prop.substring(0, colonIdx).trim()
+      seen.set(key, prop)
+    }
+  })
+
+  return prefix + ' ' + [...seen.values()].join(', ') + ' ' + suffix
+}
+
 export function justProperties(_foundClass) {
   return _foundClass.match(/{(.*)}/)[1].trim()
 }