Introduction

Overview

Flexibles (Responsive Tables) is a lightweight WordPress plugin designed to create clean, responsive tables that adapt seamlessly to all devices. It provides an intuitive admin interface for building tables without coding, ensuring accessibility and performance.

Purpose and Benefits

This plugin simplifies table creation for WordPress users, offering responsive design that works on desktops, tablets, and mobile devices. Key benefits include:

  • Easy-to-use table builder in the WordPress admin.
  • Shortcode integration for embedding tables in posts, pages, or widgets.
  • Customizable styling options for colors, borders, and layouts.
  • Lightweight code for fast loading and minimal impact on site performance.
  • Accessibility features to ensure tables are usable by screen readers and keyboard navigation.

Author and Version Information

This plugin is actively maintained and includes built-in checks for compatibility to prevent issues on unsupported environments. For the latest updates, visit the plugin’s official page.

Features

Flexibles (Responsive Tables) offers a robust set of features designed to simplify table creation and management in WordPress, ensuring high performance, accessibility, and customization. Below is a comprehensive list of its capabilities:

Core Functionality

  • Responsive Table Design: Automatically adapts tables to different screen sizes (desktop, tablet, mobile) using CSS media queries, ensuring optimal readability without horizontal scrolling on smaller devices.
  • Intuitive Admin Table Builder: A user-friendly interface in the WordPress admin dashboard for creating and editing tables. Supports adding/removing rows and columns, cell content editing, and basic formatting without requiring HTML knowledge.
  • Shortcode Integration: Embed tables anywhere on your site using shortcodes (e.g., [yl_wprt_table id="1"]). Supports parameters for customization like table ID, classes, and responsive behavior.
  • Multiple Table Types: Create various table styles, including data tables, pricing tables, comparison tables, and more, with options for headers, footers, and captions.

Customization and Styling

  • Design Controls: Customize table appearance through an admin panel, including:
    • Colors (background, text, borders).
    • Borders (width, style, color).
    • Padding and margins for cells.
    • Font sizes and families.
    • Hover effects and alternating row colors.
  • CSS Overrides: Advanced users can add custom CSS via the theme’s stylesheet or plugin settings to override default styles.
  • Theme Integration: Seamlessly integrates with popular WordPress themes, inheriting styles where possible for consistency.
  • Mobile-Specific Options: Toggle features like stackable columns on mobile, hide/show columns based on screen size, and adjust breakpoints.

Performance and Optimization

  • Lightweight Codebase: Minimal JavaScript and CSS footprint to avoid slowing down page loads. Assets are enqueued only when needed.
  • Caching Compatibility: Works with popular caching plugins (e.g., WP Rocket, W3 Total Cache) without conflicts.
  • Lazy Loading: Optional lazy loading for large tables to improve initial page load times.

Accessibility and Usability

  • WCAG Compliance: Tables are built with accessibility in mind, including proper ARIA labels, keyboard navigation support, and screen reader compatibility.
  • Semantic HTML: Uses standard 
    , , , and  elements for better SEO and readability.
  • Multilingual Support: Full internationalization (i18n) with translation-ready strings and a text domain (yl-wprt). Includes language files for easy localization.

Advanced Features

  • Data Import/Export: Import tables from CSV files or export existing tables to CSV for backup or migration.
  • Sorting and Filtering: Optional JavaScript-based sorting for columns and filtering options (requires additional setup).
  • Pagination: Break large tables into pages for better performance and user experience.
  • Hooks and Filters: Extensive WordPress hooks for developers to extend functionality, such as custom shortcode attributes, table rendering filters, and admin UI modifications.
  • Licensing System: Built-in license activation for premium features (if applicable), with secure key management and automatic updates.
  • Automatic Updates: Integrated updater checks for new versions from the official repository, with one-click updates via the WordPress admin.

Security and Compatibility

  • Environment Checks: Automatic deactivation on incompatible PHP (7.4+) or WordPress (5.0+) versions to prevent errors.
  • Secure Coding Practices: Sanitizes all user inputs, escapes outputs, and uses WordPress nonces for admin actions.
  • Fallback Mechanisms: Graceful handling of missing files or flattened installations (e.g., on some hosting providers) with admin notices.
  • No Database Tables: Stores data in WordPress options, avoiding complex database migrations.

Additional Tools

  • Debug Mode: Enable verbose logging for troubleshooting issues.
  • Admin Notices: Clear, actionable error messages for setup problems or conflicts.
  • Documentation Links: Direct links to help resources within the admin interface.

These features make Flexibles (Responsive Tables) a versatile tool for bloggers, developers, and businesses needing professional, responsive tables without bloat. For premium add-ons or advanced customizations, check the plugin’s official page.

Installation

System Requirements

Before installing Flexibles (Responsive Tables), ensure your environment meets the following minimum requirements to avoid compatibility issues:

  • WordPress Version: 5.0 or higher (tested up to 6.4).
  • PHP Version: 7.4 or higher.
  • Web Server: Apache or Nginx with standard WordPress hosting.
  • Database: MySQL 5.6+ or MariaDB 10.0+ (standard WordPress setup).
  • Browser Support: Modern browsers (Chrome, Firefox, Safari, Edge) with JavaScript enabled for admin features.
  • Additional: No special server configurations needed, but ensure allow_url_fopen is enabled for update checks.

If your site does not meet these requirements, the plugin will automatically deactivate and display an admin notice with details. It is recommended to update your PHP and WordPress versions for security and performance.

Step-by-Step Installation Instructions

Flexibles (Responsive Tables) is a premium plugin with no free version available. You must purchase it to access the full features. Follow these steps:

  1. Purchase and Download the Plugin:
  2. Installation via WordPress Admin (Recommended):
    • Log in to your WordPress admin dashboard.
    • Navigate to Plugins > Add New.
    • Click Upload Plugin.
    • Choose the downloaded ZIP file and click Install Now.
    • Wait for the installation to complete.
  3. Manual Installation via FTP:
    • Extract the ZIP file to your local computer.
    • Connect to your server via FTP (using tools like FileZilla).
    • Upload the extracted flexibles-responsive-table folder to wp-content/plugins/.
    • Ensure the folder structure is preserved (e.g., includes subfolder). If your host flattens ZIP files (unzip into root), the plugin will detect this and load files accordingly, but a warning notice will appear—reinstall to fix.
  4. Activation Process:
    • After installation, go to Plugins > Installed Plugins.
    • Locate “Flexibles (Responsive Tables)” in the list.
    • Click Activate.
    • If activation fails due to requirements (e.g., PHP < 7.4), an error notice will appear, and the plugin will deactivate automatically.

Post-Installation Notes

  • Admin Notices: Upon activation, check for any notices (e.g., flattened install warnings or licensing prompts). These are non-intrusive and provide guidance.
  • Licensing: Enter your license key in the plugin settings to enable updates and support. The plugin includes a licensing system for premium features.
  • Updates: The plugin includes an automatic updater. Check for updates under Plugins > Installed Plugins.
  • Troubleshooting: If you encounter issues like missing files, reinstall the plugin. For hosting-specific problems (e.g., flattened unzips), contact your host or reinstall manually.
  • Security: Always download from trusted sources to avoid malware. The plugin uses WordPress security best practices.

Once installed and activated, you can start creating tables via the admin menu. If you need help, refer to the Usage section or contact support.

Usage

Flexibles (Responsive Tables) provides a straightforward way to create and display responsive tables on your WordPress site. This section covers the complete process, from building tables in the admin to embedding them on the frontend, with examples and advanced options for comprehensive control.

Creating Tables via Admin Interface

The plugin's admin builder allows you to design tables without coding. Access it through the WordPress dashboard.

  1. Access the Table Builder:
    • Log in to your WordPress admin.
    • Navigate to Flexibles > Tables (or the menu item added by the plugin).
    • Click Add New Table to create a new table.
  2. Table Configuration:
    • Table Title: Enter a name for the table (used for identification in the admin list).
    • Table Settings:
      • Responsive Behavior: Choose how the table adapts (e.g., stack columns on mobile, hide certain columns).
      • Styling Options: Set default colors, borders, padding, and fonts. These can be overridden per table.
      • Accessibility: Enable features like ARIA labels and keyboard navigation.
    • Add Rows and Columns:
      • Use the visual builder to add/remove rows and columns.
      • Click on cells to edit content (supports HTML for links, images, or basic formatting).
      • Set column headers and footers if needed.
  3. Save and Preview:
    • Click Save Table to store it.
    • Use the Preview button to see how it looks on different devices (desktop, tablet, mobile).
    • Edit existing tables from the Tables list page.
  4. Bulk Actions: From the tables list, you can duplicate, export (to CSV), or delete tables.

Tables are stored in WordPress options, so no database tables are created. Each table has a unique ID for shortcode use.

Shortcode Usage for Embedding Tables

Once created, embed tables using shortcodes. This allows placement in posts, pages, widgets, or custom templates.

  1. Basic Shortcode:
    • Use [yl_wprt_table id="X"] where X is the table ID (found in the admin list).
    • Example: [yl_wprt_table id="1"] embeds table with ID 1.
  2. Shortcode Parameters:
    • id: Required. The table ID.
    • class: Optional. Add custom CSS classes (e.g., class="my-custom-table").
    • responsive: Optional. Override responsiveness (e.g., responsive="false" to disable).
    • hide_columns: Optional. Comma-separated list of column indices to hide on mobile (e.g., hide_columns="2,4").
    • stack_on_mobile: Optional. Force stacking on mobile (e.g., stack_on_mobile="true").
    • Example: [yl_wprt_table id="1" class="pricing-table" responsive="true" hide_columns="3"]
  3. Embedding in Content:
    • Posts/Pages: Paste the shortcode directly into the editor (Gutenberg or Classic).
    • Widgets: Add a Text or Custom HTML widget and insert the shortcode.
    • Templates: Use do_shortcode('[yl_wprt_table id="1"]') in PHP files like single.php.
    • Page Builders: Compatible with Elementor, Beaver Builder, etc.—add the shortcode via their text modules.
  4. Dynamic Shortcodes: For advanced users, shortcodes can be generated dynamically via PHP (e.g., in loops for multiple tables).

Frontend Display Options

Tables render responsively by default, but you can customize display.

  1. Responsive Behavior:
    • On desktop: Full table layout.
    • On tablet/mobile: Columns stack or hide based on settings. Breakpoints are customizable via CSS.
    • CSS classes are added automatically (e.g., .yl-wprt-table-responsive).
  2. Styling and Theming:
    • Default styles are enqueued only on pages with tables to avoid bloat.
    • Override with custom CSS in your theme's style.css or via the plugin's settings.
    • Example CSS: .yl-wprt-table th
  3. Performance:
    • Assets load conditionally.
    • For large tables, enable pagination or lazy loading if supported.
  4. Accessibility:
    • Tables include "caption",  "thead" and proper ARIA attributes.
    • Screen reader friendly; test with tools like WAVE.

Advanced Usage

  • Customization via Hooks: Developers can use filters like yl_wprt_table_output to modify HTML output or yl_wprt_shortcode_atts for shortcode attributes.
  • Import/Export: Export tables to CSV for editing in Excel, then re-import.
  • Sorting and Filtering: Enable via JavaScript (add custom scripts if needed).
  • Integration with Themes/Plugins: Works with caching plugins; avoid conflicts by excluding table pages from cache if dynamic content is used.
  • Debugging: Enable debug mode in settings to log issues.

Examples

  • Simple Data Table: Create a 3×3 table with headers, embed with [yl_wprt_table id="1"].
  • Pricing Table: Use custom classes for styling, e.g., [yl_wprt_table id="2" class="pricing"].
  • Mobile-Optimized: Hide non-essential columns: [yl_wprt_table id="3" hide_columns="4,5"].
  • In a Widget: Add to a sidebar widget for quick access.

For more examples or troubleshooting, check the plugin's support forum or documentation links in the admin. If you encounter issues, ensure your theme doesn't override table styles.

Customization

This section explains how to customize table appearance and behavior: design controls (colors, borders, spacing, typography), integrating with your theme, and safely overriding the plugin’s CSS/JS. Examples include recommended selectors, PHP snippets for enqueueing/dequeueing, and best practices.

Design controls (colors, borders, etc.)

  1. Global vs per‑table settings:
    • Global defaults apply site‑wide. Per‑table settings override them for a single table.
    • Use the plugin admin to set defaults and per‑table custom classes.
  2. Color palette:
    • Primary elements to style: header background, header text, row background, row text, hover/active colors, border color.
    • Selectors you can target:
    • Example CSS override:
  3. Borders, radius, and dividers:
    • Common properties: border, border-collapse, border-spacing, border-radius, box-shadow.
    • Example:
  4. Spacing & typography:
    • Adjust padding, font-size, line-height and font-family on table elements.
    • Example:
  5. Row/column states (striping, hover, selected):
    • Use :nth-child, :hover and .is-selected (or plugin-specific classes) to style states.
    • Example:
  6. Responsive-specific styling:
    • Target responsive wrappers added by the plugin (e.g., .yl-wprt-table-responsive) and breakpoint media queries in your theme.
    • Example:
  7. Custom classes & presets:
    • Apply a custom class via shortcode (example: class=”pricing”) and place CSS under that selector to scope styles.
    • Example shortcode usage:

Theme integration

  1. Conditional asset loading:
    • Prefer loading theme overrides only when tables are present to avoid performance impact.
    • Example: conditionally enqueue theme CSS only when shortcode exists:
  2. Enqueue priority & dequeueing plugin styles:
    • To override plugin CSS, load your stylesheet after the plugin, or dequeue the plugin style and re-enqueue your own. Use a higher priority (larger number) on the action.
    • Example: dequeue then add your own:
    • If you don’t know plugin handles, inspect page source or use wp_enqueue_scripts hook debug to list handles.
  3. Child theme template overrides:
    • If the plugin provides template parts and has a locate_template pattern, copy plugin templates into your theme folder (follow plugin docs). Common pattern:
    • If the plugin does not support template overrides, use provided filters to alter markup (see “hooks & filters” below) or wrap plugin markup in theme-level wrappers via output buffering in a hook.
  4. Gutenberg & block/editor styles:
    • Register editor CSS to reflect frontend styles in the block editor:

CSS/JS overrides

  1. Simple CSS overrides (best practice):
    • Place overrides in your theme (child theme) stylesheet or in a small dedicated file like /css/table-overrides.css and enqueue it after plugin assets.
    • Prefer increasing specificity instead of widespread !important usage:
  2. Inline variables & wp_add_inline_style:
    • If plugin exposes CSS variables, set them on :root or the table wrapper:
    • Example using wp_add_inline_style:
  3. Custom JS overrides & hooks:
    • To modify behavior (sorting, toggles, accessible focus handling), add a small JS file and enqueue it with the plugin script handle as dependency so it runs after plugin code.
    • Example:
    • Inside table-custom.js, hook into events the plugin triggers (or poll for DOM elements if necessary). Example pattern:
  4. Modifying HTML output via filters:
    • Look for filters like yl_wprt_table_output or yl_wprt_shortcode_atts. Use add_filter to alter markup or attributes safely.
    • Example filter (modify classes/attributes):
    • If no filter exists, use a small output filter like the_content to wrap/replace the shortcode output conditionally, but prefer plugin hooks when available.
  5. Performance & accessibility considerations:
    • Only load heavy scripts when needed; prefer CSS adjustments over JS where possible.
    • Preserve ARIA attributes and keyboard navigation—don’t remove them in overrides.

Hooks & filters (quick reference)

  • Output filter: Use plugin-provided filters to change markup before it is printed (example name: yl_wprt_table_output).
  • Shortcode attributes: Filter shortcode attributes (example name: yl_wprt_shortcode_atts) to inject classes or behavior.
  • Enqueue hooks: Use wp_enqueue_scripts and enqueue_block_editor_assets for front-end/editor assets.

Examples

  1. Basic theme CSS override:
  2. Dequeue plugin CSS and enqueue theme CSS:
  3. Enqueue custom JS that depends on plugin script:

Troubleshooting & tips

  • Debugging: Inspect page source to find plugin handles and classes. Use browser devtools to test selectors and media queries live.
  • Specificity issues: If your rules are ignored, increase selector specificity or adjust enqueue priority instead of using !important.
  • No hooks available: If the plugin lacks filters for your need, use the_content or a short output buffer hook as a last resort, but open a feature request with plugin author for proper hooks.
  • Backup: When modifying theme or plugin templates, keep backups and use a child theme for safe updates.

For specific class names, script/style handles, or template paths used by the plugin, inspect the plugin source or the page source and adjust the examples above to those names. If you want, provide the plugin’s main PHP file or a sample page HTML and I can give exact handles and selectors.

Technical Details

This section provides in-depth information for developers and advanced users: the plugin’s file structure, available hooks and filters for customization, licensing and update mechanisms, and security/privacy considerations. Understanding these will help with troubleshooting, extending the plugin, or integrating it into custom workflows.

File structure

The plugin follows a modular structure to keep code organized and maintainable. All files are located under the plugin directory (wp-content/plugins/flexibles-responsive-table/). Below is a breakdown of key directories and files, including their purposes and any notes on dependencies or fallbacks.

  1. Root files:
    • wp-responsive-table.php: Main plugin file. Handles initialization, requirements checks, constants, and loading of components. Includes safety checks for PHP/WordPress versions and graceful deactivation on incompatibilities.
    • readme.txt: Standard WordPress readme file with plugin description, installation instructions, changelog, and FAQ.
    • languages/: Directory for translation files (.po/.mo files) for internationalization support.
    • assets/: Contains CSS, JS, and image files for the admin interface and frontend. Subdirectories may include css/, js/, and images/.
  2. Includes directory (includes/):
    • class-yl-wprt-table.php: Core class for table data handling, including creation, storage, and rendering logic.
    • class-yl-wprt-assets.php: Manages enqueueing of stylesheets and scripts, both for admin and frontend, with conditional loading to optimize performance.
    • class-yl-wprt-shortcode.php: Handles the shortcode registration and processing, including attribute parsing and output generation.
    • class-yl-wprt-admin.php: Contains admin-side functionality, such as menu registration, table builder interface, and settings pages.
    • class-yl-wprt-updater.php: Manages plugin updates via the WordPress update system or external APIs (e.g., for premium features).
    • class-yl-wprt-license.php: (Optional, may not be present in free versions) Handles licensing activation, validation, and status checks for premium features.
  3. Templates directory (templates/):
    • table.php: Template file for rendering the table HTML. Can be overridden by themes for customization (see Theme Integration in Customization section).
    • Other template files may exist for specific views, like admin previews or export formats.
  4. Notes on structure and fallbacks:
    • The plugin includes fallback loading for files in case of hosting issues (e.g., if subdirectories are flattened). If files are missing, the plugin deactivates with an admin notice.
    • No custom database tables are created; all data is stored in WordPress options (wp_options table).
    • Constants defined: YL_WPRT_VERSION, YL_WPRT_PLUGIN_DIR, YL_WPRT_PLUGIN_URL, etc., for easy path references.
    • Dependencies: Relies on WordPress core functions; no external libraries beyond what’s included.

Hooks and filters

The plugin provides several hooks and filters for developers to extend or modify functionality without editing core files. These are action hooks for side effects and filters for modifying data. Always check the plugin’s source code for the latest list, as they may evolve with updates.

  1. Action hooks:
    • yl_wprt_init: Fired after plugin initialization. Useful for adding custom setup code.
    • yl_wprt_admin_menu: Allows modifying the admin menu structure before it’s registered.
    • yl_wprt_enqueue_assets: Triggered before assets are enqueued; ideal for conditional loading or adding dependencies.
    • yl_wprt_table_rendered: Fired after a table is rendered on the frontend. Parameters: table ID and HTML output.
  2. Filters:
    • yl_wprt_table_output: Modify the final HTML output of a table. Parameters: HTML string, table ID, and attributes array.
    • yl_wprt_shortcode_atts: Alter shortcode attributes before processing. Parameters: attributes array and shortcode name.
    • yl_wprt_table_data: Filter table data before rendering. Useful for dynamic content injection.
    • yl_wprt_asset_handles: Modify enqueued asset handles (CSS/JS) for custom loading.
    • yl_wprt_responsive_breakpoints: Adjust responsive breakpoints (e.g., for custom media queries).
  3. Usage examples and best practices:
    • Use filters to add custom classes or data attributes without overriding templates.
    • Actions can be used for logging or integrating with third-party plugins (e.g., caching or analytics).
    • Always specify priority (third parameter in add_action/add_filter) to control execution order; higher numbers run later.
    • Test hooks in a development environment to avoid conflicts.

Licensing and updates

The plugin supports both free and premium versions. Licensing ensures access to updates and premium features, while updates are handled securely via WordPress or external APIs.

  1. License management:
    • Licensing is handled by the YL_WPRT_License class (in class-yl-wprt-license.php).
    • Methods include: activate($key), deactivate(), check(), is_active(), and get_status().
    • License keys are stored securely in WordPress options. Activation requires a valid key from the vendor (Yellow Lamp).
    • If the license file is missing (e.g., in free versions), a fallback class provides dummy methods to prevent errors.
  2. Update mechanism:
    • Updates are managed by the YL_WPRT_Updater class, which integrates with WordPress’ update system or external update APIs.
    • For premium users, it checks for updates against the vendor’s server using the license key.
    • Free versions rely on WordPress.org for updates if available.
    • Update URI is set to false in the header to prevent conflicts, but the updater class handles it.
  3. Activation and deactivation:
    • Plugin activation/deactivation uses standard WordPress hooks (register_activation_hook/register_deactivation_hook). No database changes occur.
    • On incompatible environments (e.g., old PHP), the plugin deactivates automatically with notices.
  4. Notes and troubleshooting:
    • License issues may prevent updates; check status via admin settings.
    • Updates are tested up to WordPress 6.4; always backup before updating.
    • If updates fail, ensure wp-content/ is writable and no security plugins block API calls.

Security and privacy notes

The plugin adheres to WordPress security best practices. It does not collect or transmit user data externally, ensuring compliance with privacy regulations like GDPR.

  1. Data storage and handling:
    • All table data is stored in WordPress options, which are serialized and stored securely in the database.
    • No personal user data is collected or sent to external servers unless explicitly configured (e.g., for licensing checks).
    • Inputs are sanitized using WordPress functions like sanitize_text_field() and wp_kses() to prevent XSS.
  2. External requests and APIs:
    • Licensing and update checks may make HTTPS requests to the vendor’s server (yellowlamp.shop). These are secure and only transmit license keys and site URLs.
    • No tracking or analytics data is sent without user consent.
  3. Access controls and permissions:
    • Admin functions require manage_options capability.
    • Shortcodes are processed safely, with attribute validation to prevent injection attacks.
    • Direct file access is prevented via if (!defined('ABSPATH')) exit; guards.
  4. Privacy compliance:
    • The plugin does not use cookies, tracking pixels, or embed external scripts by default.
    • No user data is shared with third parties. For GDPR/CCPA, inform users if licensing involves data transmission.
    • Assets are loaded conditionally to minimize exposure.
  5. Best practices and recommendations:
    • Keep the plugin updated to patch security vulnerabilities.
    • Use HTTPS on your site to encrypt any data transmission.
    • If customizing, avoid adding unsafe code; use WordPress APIs for database interactions.
    • Report security issues to the developer via official channels.

Troubleshooting

This section helps resolve common issues with Flexibles (Responsive Tables). Start with the basics: ensure your WordPress and PHP versions meet requirements (WP 5.0+, PHP 7.4+). If problems persist, enable debug mode and check logs. For unresolved issues, use the support resources below.

Common issues and solutions

  1. Plugin not activating or showing errors:
    • Cause: Incompatible PHP/WordPress versions or missing core files.
    • Solution: Check your PHP version (via Tools > Site Health) and update if below 7.4. Update WordPress to 5.0+. If files are missing, reinstall the plugin. The plugin deactivates automatically with a notice if requirements aren’t met.
  2. Tables not displaying on frontend:
    • Cause: Shortcode syntax error, missing table ID, or theme conflicts.
    • Solution: Verify the shortcode format: [yl_wprt_table id="X"] (replace X with a valid table ID from the admin list). Check for PHP errors in debug mode. Disable other plugins temporarily to rule out conflicts.
  3. Responsive behavior not working:
    • Cause: CSS overrides, caching, or missing assets.
    • Solution: Clear site cache and browser cache. Ensure plugin CSS/JS loads (check page source for yl-wprt-styles). Avoid overriding .yl-wprt-table-responsive classes in your theme.
  4. Admin table builder not loading:
    • Cause: JavaScript errors or permission issues.
    • Solution: Ensure you’re logged in as an admin. Check browser console for JS errors. Deactivate plugins like security/firewall tools that might block scripts.
  5. Licensing activation errors:
    • Cause: Invalid key, network issues, or server blocks.
    • Solution: Verify the license key from your purchase email. Ensure your site can make HTTPS requests (check with a tool like curl). If blocked, contact your host. Use YL_WPRT_License::check() in debug mode for status.
  6. Custom styling not applying:
    • Cause: CSS specificity issues or enqueue order.
    • Solution: Increase selector specificity (e.g., body .yl-wprt-table th). Enqueue your CSS after plugin styles (priority >20 in wp_enqueue_scripts). Avoid !important unless necessary.
  7. Performance issues (slow loading):
    • Cause: Large tables or unconditional asset loading.
    • Solution: Enable pagination if available, or split large tables. Assets load only on pages with tables—confirm via Query Monitor plugin. Optimize images in table cells.
  8. Table data lost or corrupted:
    • Cause: Plugin updates, theme changes, or database issues.
    • Solution: Backup tables via export (CSV). Restore from backups. Data is stored in wp_options; check for corruption with a DB tool.

Debug mode

Enable debug mode to log errors and inspect plugin behavior. This is essential for diagnosing issues not covered above.

  1. Enable WordPress debug mode:
    • Add to wp-config.php:
    • This logs errors to wp-content/debug.log without showing them on the site.
  2. Plugin-specific debug options:
    • The plugin includes debug notices for missing files or flattened installs (visible in admin).
    • For licensing, call YL_WPRT_License::get_status() in a custom snippet or use the admin settings page.
    • Check asset loading: Inspect page source for enqueued scripts/styles (e.g., yl-wprt-styles).
  3. Testing with tools:
    • Use Query Monitor plugin to inspect queries, assets, and hooks.
    • Browser dev tools: Check console for JS errors and network tab for failed asset loads.
    • Test responsiveness: Use browser responsive mode or tools like BrowserStack.
  4. Safe debugging practices:
    • Disable debug on production sites to avoid exposing sensitive info.
    • After fixing, remove debug constants and clear the log file.
    • If issues persist, share sanitized log excerpts (remove personal data) with support.

Support resources

If troubleshooting doesn’t resolve your issue, reach out for help. Provide details like WordPress/PHP versions, error logs, and steps to reproduce.

  1. Official documentation:
  2. Community support:
    • WordPress.org forums: Post in the plugin’s support thread.
    • GitHub issues (if applicable): Check or open issues at the plugin’s repository.
  3. Premium support:
    • For licensed users: Email support@yellowlamp.shop with your license key and site details.
    • Response time: Within 24-48 hours.
  4. Additional help:
    • WordPress Codex: General troubleshooting at wordpress.org/support.
    • Third-party resources: Stack Overflow for code-specific issues.
    • Report bugs: Use the contact form on yellowlamp.shop.

License

This section outlines the licensing terms for Flexibles (Responsive Tables), including the open-source license and credits for contributors and resources used.

Licensing information (GPL v2 or later)

  1. GPL v2 or later license:
    • The plugin is licensed under the GNU General Public License (GPL) version 2 or later, as specified in the plugin header.
    • This is a free, open-source license that allows you to use, modify, and distribute the plugin under the same terms.
    • Full license text: https://www.gnu.org/licenses/gpl-2.0.html
  2. Rights and restrictions:
    • Rights: You can freely install, use, and modify the plugin for personal or commercial use, as long as modifications are also GPL-licensed.
    • Restrictions: You cannot remove or alter the license notices in the code. Redistribution must include the original license.
    • If you distribute modified versions, you must make the source code available.
  3. Premium features and licensing:
    • Some features may require a premium license from Yellow Lamp. These are not covered under GPL and require separate purchase.
    • Premium licensing is handled via the YL_WPRT_License class, with activation through a unique key.
    • Premium support and updates are available for licensed users.
  4. Compliance and updates:
    • The plugin complies with WordPress.org guidelines for GPL-licensed plugins.
    • Updates are provided via WordPress.org or the developer’s site, depending on the version.
    • For legal questions, consult a lawyer or refer to the GPL FAQ.

Credits and acknowledgments

  1. Author and development:
    • Author: Yellow Lamp (https://yellowlamp.shop)
    • The plugin was developed by Yellow Lamp to provide a lightweight, responsive table solution for WordPress.
  2. Contributions and community:
    • Community feedback and bug reports from WordPress.org users have helped improve the plugin.
    • No external contributors are credited in the current version, but pull requests and issues are welcome on the official repository.
  3. Resources and libraries:
    • The plugin uses WordPress core functions and APIs; no third-party libraries are included.
    • Inspiration from responsive table techniques in web development best practices.
    • Icons and assets are original or from free sources compatible with GPL.
  4. Special thanks:
    • Thanks to the WordPress community for providing a robust platform.
    • Acknowledgments to users who have supported the plugin through reviews and donations.