tailwind-to-style 3.2.2 → 4.0.0

package/dist/core/tws.esm.js

@@ -1,13 +1,13 @@
 /**
- * tailwind-to-style v3.2.2
- * Runtime Tailwind CSS to inline styles converter
+ * tailwind-to-style v4.0.0
+ * Zero-build runtime Tailwind CSS engine
  * 
  * @author Bigetion
  * @license MIT
  */
-/**
- * TailwindCache singleton for managing generated Tailwind CSS
- * Replaces global state with proper encapsulation
+/**
+ * TailwindCache singleton for managing generated Tailwind CSS
+ * Replaces global state with proper encapsulation
  */
 class TailwindCache {
   constructor() {
@@ -16,11 +16,11 @@ class TailwindCache {
     this.initialized = false;
   }
 
-  /**
-   * Get or generate the CSS object
-   * @param {Function} generateFn - Function to generate CSS string
-   * @param {Function} convertFn - Function to convert CSS string to object
-   * @returns {Object} CSS object lookup
+  /**
+   * Get or generate the CSS object
+   * @param {Function} generateFn - Function to generate CSS string
+   * @param {Function} convertFn - Function to convert CSS string to object
+   * @returns {Object} CSS object lookup
    */
   getOrGenerate(generateFn, convertFn) {
     if (!this.initialized) {
@@ -31,29 +31,29 @@ class TailwindCache {
     return this.cssObject;
   }
 
-  /**
-   * Get the CSS string
+  /**
+   * Get the CSS string
    */
   getCssString() {
     return this.twString;
   }
 
-  /**
-   * Get the CSS object
+  /**
+   * Get the CSS object
    */
   getCssObject() {
     return this.cssObject;
   }
 
-  /**
-   * Check if cache is initialized
+  /**
+   * Check if cache is initialized
    */
   isInitialized() {
     return this.initialized;
   }
 
-  /**
-   * Reset the cache (useful for testing)
+  /**
+   * Reset the cache (useful for testing)
    */
   reset() {
     this.twString = null;
@@ -65,9 +65,9 @@ class TailwindCache {
 // Singleton instance
 let instance = null;
 
-/**
- * Get the TailwindCache singleton instance
- * @returns {TailwindCache} The cache instance
+/**
+ * Get the TailwindCache singleton instance
+ * @returns {TailwindCache} The cache instance
  */
 function getTailwindCache() {
   if (!instance) {
@@ -76,9 +76,9 @@ function getTailwindCache() {
   return instance;
 }
 
-/**
- * Logger class with configurable log levels
- * Prevents console spam in production
+/**
+ * Logger class with configurable log levels
+ * Prevents console spam in production
  */
 class Logger {
   constructor() {
@@ -93,9 +93,9 @@ class Logger {
     };
   }
 
-  /**
-   * Set the log level
-   * @param {string} level - One of 'debug', 'info', 'warn', 'error', 'silent'
+  /**
+   * Set the log level
+   * @param {string} level - One of 'debug', 'info', 'warn', 'error', 'silent'
    */
   setLevel(level) {
     if (this.levels[level] !== undefined) {
@@ -103,65 +103,65 @@ class Logger {
     }
   }
 
-  /**
-   * Get current log level
+  /**
+   * Get current log level
    */
   getLevel() {
     return this.level;
   }
 
-  /**
-   * Check if a message should be logged
+  /**
+   * Check if a message should be logged
    */
   shouldLog(level) {
     return this.levels[level] >= this.levels[this.level];
   }
 
-  /**
-   * Log debug message
+  /**
+   * Log debug message
    */
   debug(message) {
     if (this.shouldLog("debug")) {
       for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
         args[_key - 1] = arguments[_key];
       }
-      console.debug(`[twsx:debug] ${message}`, ...args);
+      console.debug("[twsx:debug] ".concat(message), ...args);
     }
   }
 
-  /**
-   * Log info message
+  /**
+   * Log info message
    */
   info(message) {
     if (this.shouldLog("info")) {
       for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
         args[_key2 - 1] = arguments[_key2];
       }
-      console.info(`[twsx:info] ${message}`, ...args);
+      console.info("[twsx:info] ".concat(message), ...args);
     }
   }
 
-  /**
-   * Log warning message
+  /**
+   * Log warning message
    */
   warn(message) {
     if (this.shouldLog("warn")) {
       for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
         args[_key3 - 1] = arguments[_key3];
       }
-      console.warn(`[twsx:warn] ${message}`, ...args);
+      console.warn("[twsx:warn] ".concat(message), ...args);
     }
   }
 
-  /**
-   * Log error message
+  /**
+   * Log error message
    */
   error(message) {
     if (this.shouldLog("error")) {
       for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
         args[_key4 - 1] = arguments[_key4];
       }
-      console.error(`[twsx:error] ${message}`, ...args);
+      console.error("[twsx:error] ".concat(message), ...args);
     }
   }
 }
@@ -175,14 +175,14 @@ try {
     // e.g., TWSX_LOG_LEVEL=debug or TWSX_LOG_LEVEL=warn
     logLevel = process.env.TWSX_LOG_LEVEL || "silent";
   }
-} catch {
+} catch (_unused) {
   // Silently fail - in browser environment, default to silent
   logLevel = "silent";
 }
 const logger = new Logger(logLevel);
 
-/**
- * Custom error class for tailwind-to-style
+/**
+ * Custom error class for tailwind-to-style
  */
 class TwsError extends Error {
   constructor(message) {
@@ -194,15 +194,15 @@ class TwsError extends Error {
   }
 }
 
-/**
- * Error event handlers
+/**
+ * Error event handlers
  */
 const errorHandlers = new Set();
 
-/**
- * Handle and broadcast errors
- * @param {Error} error - The error that occurred
- * @param {Object} context - Additional context about the error
+/**
+ * Handle and broadcast errors
+ * @param {Error} error - The error that occurred
+ * @param {Object} context - Additional context about the error
  */
 function handleError(error) {
   let context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -261,7 +261,7 @@ const performanceMonitor = {
     const duration = performance.now() - marker.startTime;
     if (duration > 5) {
       // Only log if > 5ms
-      logger.warn(`Slow ${marker.label}: ${duration.toFixed(2)}ms`);
+      logger.warn("Slow ".concat(marker.label, ": ").concat(duration.toFixed(2), "ms"));
     }
   },
   /**
@@ -284,9 +284,53 @@ const performanceMonitor = {
   }
 };
 
-/**
- * Proper LRU (Least Recently Used) Cache implementation
- * Efficiently manages memory by removing least recently used items
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+/**
+ * Proper LRU (Least Recently Used) Cache implementation
+ * Efficiently manages memory by removing least recently used items
  */
 class LRUCache {
   constructor() {
@@ -295,9 +339,9 @@ class LRUCache {
     this.cache = new Map();
   }
 
-  /**
-   * Get value from cache
-   * Updates the item as most recently used
+  /**
+   * Get value from cache
+   * Updates the item as most recently used
    */
   get(key) {
     if (!this.cache.has(key)) {
@@ -310,9 +354,9 @@ class LRUCache {
     return value;
   }
 
-  /**
-   * Set value in cache
-   * Removes least recently used item if cache is full
+  /**
+   * Set value in cache
+   * Removes least recently used item if cache is full
    */
   set(key, value) {
     // If key exists, delete it first to update position
@@ -326,29 +370,29 @@ class LRUCache {
     this.cache.set(key, value);
   }
 
-  /**
-   * Check if key exists in cache
+  /**
+   * Check if key exists in cache
    */
   has(key) {
     return this.cache.has(key);
   }
 
-  /**
-   * Clear all cache entries
+  /**
+   * Clear all cache entries
    */
   clear() {
     this.cache.clear();
   }
 
-  /**
-   * Get current cache size
+  /**
+   * Get current cache size
    */
   get size() {
     return this.cache.size;
   }
 
-  /**
-   * Delete specific key
+  /**
+   * Delete specific key
    */
   delete(key) {
     return this.cache.delete(key);
@@ -426,11 +470,11 @@ const COLOR_REGEX_PATTERNS = new Map();
 for (const prop of COLOR_PROPERTIES) {
   const escapedProp = prop.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   COLOR_REGEX_PATTERNS.set(prop, {
-    rgb: new RegExp(`(${escapedProp}\\s*:\\s*)rgb\\((\\d+),\\s*(\\d+),\\s*(\\d+)\\)`, "gi"),
-    rgba: new RegExp(`(${escapedProp}\\s*:\\s*)rgba\\((\\d+),\\s*(\\d+),\\s*(\\d+),\\s*[\\d.]+\\)`, "gi"),
-    hsl: new RegExp(`(${escapedProp}\\s*:\\s*)hsl\\((\\d+),\\s*([\\d.]+%),\\s*([\\d.]+%)\\)`, "gi"),
-    hsla: new RegExp(`(${escapedProp}\\s*:\\s*)hsla\\((\\d+),\\s*([\\d.]+%),\\s*([\\d.]+%),\\s*[\\d.]+\\)`, "gi"),
-    hex: new RegExp(`(${escapedProp}\\s*:\\s*)(#[0-9a-fA-F]{3,6})`, "gi")
+    rgb: new RegExp("(".concat(escapedProp, "\\s*:\\s*)rgb\\((\\d+),\\s*(\\d+),\\s*(\\d+)\\)"), "gi"),
+    rgba: new RegExp("(".concat(escapedProp, "\\s*:\\s*)rgba\\((\\d+),\\s*(\\d+),\\s*(\\d+),\\s*[\\d.]+\\)"), "gi"),
+    hsl: new RegExp("(".concat(escapedProp, "\\s*:\\s*)hsl\\((\\d+),\\s*([\\d.]+%),\\s*([\\d.]+%)\\)"), "gi"),
+    hsla: new RegExp("(".concat(escapedProp, "\\s*:\\s*)hsla\\((\\d+),\\s*([\\d.]+%),\\s*([\\d.]+%),\\s*[\\d.]+\\)"), "gi"),
+    hex: new RegExp("(".concat(escapedProp, "\\s*:\\s*)(#[0-9a-fA-F]{3,6})"), "gi")
   });
 }
 
@@ -444,16 +488,6 @@ const FRACTION_DENOMINATORS = [2, 3, 4, 5, 6, 12];
 /** Prefixes that support fractional values */
 const FRACTION_PREFIXES = ["w-", "h-", "max-w-", "max-h-", "min-w-", "min-h-", "top-", "bottom-", "left-", "right-", "inset-", "inset-x-", "inset-y-", "translate-x-", "translate-y-", "rounded-t-", "rounded-b-", "rounded-l-", "rounded-r-", "rounded-bl-", "rounded-br-", "rounded-tl-", "rounded-tr-", "flex-basis-", "z-"];
 
-/**
- * CSS Resolution Utilities
- * 
- * Handles CSS custom property (var) resolution, CSS declaration parsing,
- * and conversion between different CSS formats.
- * 
- * @module css/resolver
- */
-
-
 // Cache for CSS resolution
 const cssResolutionCache = new LRUCache(1000);
 
@@ -508,11 +542,11 @@ function resolveCssToClearCss(cssString) {
   const varKeys = Object.keys(customVars);
   for (let i = 0; i < varKeys.length; i++) {
     const key = varKeys[i];
-    result += `${key}: ${customVars[key]}; `;
+    result += "".concat(key, ": ").concat(customVars[key], "; ");
   }
   for (let i = 0; i < propKeys.length; i++) {
     const key = propKeys[i];
-    result += `${key}: ${props[key]}; `;
+    result += "".concat(key, ": ").concat(props[key], "; ");
   }
   return result.trim();
 }
@@ -563,9 +597,7 @@ function separateAndResolveCSS(arr) {
         logger.warn("Error processing CSS declaration:", item, error);
       }
     }
-    const resolvedProperties = {
-      ...cssProperties
-    };
+    const resolvedProperties = _objectSpread2({}, cssProperties);
 
     /**
      * Optimized CSS variable resolution using regex-based approach
@@ -639,7 +671,7 @@ function separateAndResolveCSS(arr) {
     const finalKeys = Object.keys(resolvedProperties);
     for (let i = 0; i < finalKeys.length; i++) {
       const key = finalKeys[i];
-      result += `${key}: ${resolvedProperties[key]}; `;
+      result += "".concat(key, ": ").concat(resolvedProperties[key], "; ");
     }
     result = result.trim();
     cssResolutionCache.set(cacheKey, result);
@@ -707,16 +739,6 @@ function inlineStyleToJson(styleString) {
   return styleObject;
 }
 
-/**
- * CSS Parser Utilities
- * 
- * Handles parsing of Tailwind class names, opacity modifiers,
- * bracket value encoding/decoding, and custom value extraction.
- * 
- * @module css/parser
- */
-
-
 /**
  * Process opacity modifier from class name
  * 
@@ -745,7 +767,7 @@ function processOpacityModifier(className, cssDeclaration) {
   for (const prop in OPACITY_PROP_REGEXES) {
     const regex = OPACITY_PROP_REGEXES[prop];
     regex.lastIndex = 0; // Reset global regex
-    modifiedDeclaration = modifiedDeclaration.replace(regex, `${prop}: ${alphaValue}`);
+    modifiedDeclaration = modifiedDeclaration.replace(regex, "".concat(prop, ": ").concat(alphaValue));
   }
 
   // Also handle direct color values using pre-compiled regex patterns
@@ -761,16 +783,16 @@ function processOpacityModifier(className, cssDeclaration) {
     patterns.hex.lastIndex = 0;
 
     // Convert rgb to rgba with opacity
-    modifiedDeclaration = modifiedDeclaration.replace(patterns.rgb, `$1rgba($2, $3, $4, ${alphaValue})`);
+    modifiedDeclaration = modifiedDeclaration.replace(patterns.rgb, "$1rgba($2, $3, $4, ".concat(alphaValue, ")"));
 
     // Update existing rgba opacity
-    modifiedDeclaration = modifiedDeclaration.replace(patterns.rgba, `$1rgba($2, $3, $4, ${alphaValue})`);
+    modifiedDeclaration = modifiedDeclaration.replace(patterns.rgba, "$1rgba($2, $3, $4, ".concat(alphaValue, ")"));
 
     // Convert hsl to hsla with opacity
-    modifiedDeclaration = modifiedDeclaration.replace(patterns.hsl, `$1hsla($2, $3, $4, ${alphaValue})`);
+    modifiedDeclaration = modifiedDeclaration.replace(patterns.hsl, "$1hsla($2, $3, $4, ".concat(alphaValue, ")"));
 
     // Update existing hsla opacity
-    modifiedDeclaration = modifiedDeclaration.replace(patterns.hsla, `$1hsla($2, $3, $4, ${alphaValue})`);
+    modifiedDeclaration = modifiedDeclaration.replace(patterns.hsla, "$1hsla($2, $3, $4, ".concat(alphaValue, ")"));
 
     // Handle hex colors - convert to rgba
     modifiedDeclaration = modifiedDeclaration.replace(patterns.hex, (match, propPart, hexColor) => {
@@ -786,7 +808,7 @@ function processOpacityModifier(className, cssDeclaration) {
         g = parseInt(hex.substring(2, 4), 16);
         b = parseInt(hex.substring(4, 6), 16);
       }
-      return `${propPart}rgba(${r}, ${g}, ${b}, ${alphaValue})`;
+      return "".concat(propPart, "rgba(").concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(alphaValue, ")");
     });
   }
   return modifiedDeclaration;
@@ -861,12 +883,12 @@ function tws(classNames) {
 
       // If no valid classes are found
       if (!classes || classes.length === 0) {
-        logger.warn(`No valid Tailwind classes found in input: "${classNames}"`);
+        logger.warn("No valid Tailwind classes found in input: \"".concat(classNames, "\""));
         performanceMonitor.end(totalMarker);
         return convertToJson ? {} : "";
       }
     } catch (error) {
-      logger.error(`Error parsing Tailwind classes: ${error.message}`);
+      logger.error("Error parsing Tailwind classes: ".concat(error.message));
       performanceMonitor.end(totalMarker);
       return convertToJson ? {} : "";
     }
@@ -886,7 +908,7 @@ function tws(classNames) {
         if (opacityValue >= 0 && opacityValue <= 100) {
           // Check if this could be a fraction (e.g., w-2/3, h-1/2)
           // Fractions typically have denominators of 2, 3, 4, 5, 6, 12
-          const couldBeFraction = FRACTION_DENOMINATORS.includes(opacityValue) && FRACTION_PREFIXES.some(prefix => className.startsWith(prefix) || className.startsWith(`-${prefix}`));
+          const couldBeFraction = FRACTION_DENOMINATORS.includes(opacityValue) && FRACTION_PREFIXES.some(prefix => className.startsWith(prefix) || className.startsWith("-".concat(prefix)));
           if (!couldBeFraction) {
             baseClassName = className.replace(/\/\d+$/, "");
             hasOpacityModifier = true;
@@ -905,8 +927,8 @@ function tws(classNames) {
         if (match) {
           const customValue = match[1];
           const baseKey = baseClassName.split("[")[0];
-          if (cssObject[`${baseKey}custom`]) {
-            let customResult = cssObject[`${baseKey}custom`].replace(/custom_value/g, customValue);
+          if (cssObject["".concat(baseKey, "custom")]) {
+            let customResult = cssObject["".concat(baseKey, "custom")].replace(/custom_value/g, customValue);
             // Apply opacity modifier to custom values too
             if (hasOpacityModifier && className.includes("/") && /\/\d+$/.test(className)) {
               customResult = processOpacityModifier(className, customResult);
@@ -960,14 +982,14 @@ function debounce(func) {
     callCount++;
     clearTimeout(timeout);
     timeout = setTimeout(() => {
-      const marker = performanceMonitor.start(`debounced:${func.name || "anonymous"}`);
+      const marker = performanceMonitor.start("debounced:".concat(func.name || "anonymous"));
       try {
         const result = func.apply(context, args);
         performanceMonitor.end(marker);
         return result;
       } catch (error) {
         performanceMonitor.end(marker);
-        logger.error(`Debounced function error (call #${callCount}):`, error);
+        logger.error("Debounced function error (call #".concat(callCount, "):"), error);
         throw error;
       }
     }, wait);