JavaScript Utilities

/**
 * Adds a prefix to CSS class names and custom properties in a style object
 * @param obj - CSS style object to process
 * @param prefix - String prefix to add to class names and variables
 * @param excludedPrefixes - Array of variable prefixes to exclude from prefixing
 * @returns Processed style object with prefixed class names and variables
 */
function addPrefix(
  obj: Record<string, any>, 
  prefix: string, 
  excludedPrefixes?: string[]
): Record<string, any>;

import { addPrefix } from 'daisyui/functions/addPrefix';

// Basic usage
const styles = {
  '.btn': {
    padding: '0.5rem 1rem',
    'border-radius': '0.375rem',
  },
  '.btn-primary': {
    'background-color': 'var(--color-primary)',
    color: 'var(--color-primary-content)',
  }
};

const prefixedStyles = addPrefix(styles, 'my-');
// Result:
// {
//   '.my-btn': {
//     padding: '0.5rem 1rem',
//     'border-radius': '0.375rem',
//   },
//   '.my-btn-primary': {
//     'background-color': 'var(--my-color-primary)',
//     color: 'var(--my-color-primary-content)',
//   }
// }

// With excluded prefixes
const excludedPrefixes = ['tw', 'color-'];
const customStyles = {
  '.card': {
    'background-color': 'var(--color-base-100)', // Won't be prefixed
    'border-color': 'var(--my-custom-border)',   // Will be prefixed
  }
};

const result = addPrefix(customStyles, 'ui-', excludedPrefixes);

/**
 * Plugin creation utility with options support
 */
const plugin: {
  /**
   * Creates a plugin with configurable options
   * @param pluginFunction - Function that returns the plugin implementation
   * @param configFunction - Optional function that returns theme configuration
   * @returns Plugin function compatible with Tailwind CSS
   */
  withOptions: <T = any>(
    pluginFunction: (options?: T) => (tailwind: {
      addBase: (styles: Record<string, any>) => void;
      addComponents: (styles: Record<string, any>) => void;
      addUtilities: (styles: Record<string, any>) => void;
    }) => void,
    configFunction?: (options?: T) => any
  ) => any;
};

import { plugin } from 'daisyui/functions/plugin';

// Create a custom plugin with options
const myPlugin = plugin.withOptions(
  (options = {}) => {
    return ({ addComponents, addUtilities }) => {
      const { prefix = '', includeButtons = true } = options;
      
      if (includeButtons) {
        addComponents({
          [`.${prefix}my-btn`]: {
            padding: '0.5rem 1rem',
            'border-radius': '0.375rem',
          }
        });
      }
    };
  },
  (options = {}) => ({
    theme: {
      extend: {
        colors: options.customColors || {}
      }
    }
  })
);

// Use in Tailwind config
module.exports = {
  plugins: [
    myPlugin({
      prefix: 'custom-',
      includeButtons: true,
      customColors: {
        brand: '#ff6b6b'
      }
    })
  ]
};

/**
 * Processes plugin configuration options and applies theme styles
 * @param options - Plugin configuration options
 * @param addBase - Tailwind's addBase function for base styles
 * @param themesObject - Object containing all available theme definitions
 * @param packageVersion - DaisyUI package version for logging
 * @returns Processed configuration with include/exclude arrays and prefix
 */
function pluginOptionsHandler(
  options: PluginOptions | undefined,
  addBase: (styles: Record<string, any>) => void,
  themesObject: Record<string, any>,
  packageVersion: string
): {
  include?: string[];
  exclude?: string[];
  prefix: string;
};

import { pluginOptionsHandler } from 'daisyui/functions/pluginOptionsHandler';
import themesObject from 'daisyui/theme/object';

// This function is typically used internally by the main DaisyUI plugin
const processedOptions = pluginOptionsHandler(
  {
    themes: ['light --default', 'dark --prefersdark'],
    prefix: 'dui-',
    logs: false,
    include: ['button', 'card'],
    exclude: ['calendar']
  },
  addBase,
  themesObject,
  '5.1.6'
);

// Returns: { include: ['button', 'card'], exclude: ['calendar'], prefix: 'dui-' }

interface PluginUtility {
  withOptions: <T = any>(
    pluginFunction: (options?: T) => (tailwind: any) => void,
    configFunction?: (options?: T) => any
  ) => any;
}

interface PluginOptionsResult {
  include?: string[];
  exclude?: string[];
  prefix: string;
}

// Default excluded prefixes for addPrefix function
type DefaultExcludedPrefixes = readonly [
  "color-", "size-", "radius-", "border", "depth", "noise"
];