fix: correctly detect ACF taxonomies by checking post_content

includes/Admin/Forms/Admin_Form_Builder.php

@@ -43,11 +43,11 @@
             'form_settings_key' => '',
             'post_id'           => 0,
             'shortcodes'        => [],
             // [ [ 'name' => 'wpuf_form', 'type' => 'profile' ], [ 'name' => 'wpuf_form', 'type' => 'registration' ] ]
         ];
         $this->settings = wp_parse_args( $settings, $defaults );
         // set post data to global $post
         $post = get_post( $this->settings['post_id'] );
         // if we have an existing post, then let's start
         if ( ! empty( $post->ID ) ) {
             add_action( 'in_admin_header', 'wpuf_remove_admin_notices' );
@@ -125,15 +125,15 @@
 
         $single_objects = apply_filters(
             'wpuf_single_form_field',
                 [
                 'post_title',
                 'post_content',
                 'post_excerpt',
                 'featured_image',
                 'user_login',
                 'first_name',
                 'last_name',
                 'nickname',
                 'user_email',
                 'user_url',
                 'user_bio',
@@ -338,7 +338,7 @@
                 'last_column_warn_msg'    => __( 'This field must contain at least one column', 'wp-user-frontend' ),
                 'is_a_pro_feature'        => __( 'is a pro feature', 'wp-user-frontend' ),
                 'pro_feature_msg'         => __(
                     '<p class="wpuf-text-gray-500 wpuf-font-medium wpuf-text-xl">Please upgrade to the Pro version to unlock all these awesome features</p>',
                     'wp-user-frontend'
                 ),
                 'upgrade_to_pro'          => __( 'Upgrade to PRO', 'wp-user-frontend' ),
@@ -362,15 +362,15 @@
      */
     public static function save_form( $data ) {
         $saved_wpuf_inputs = [];
         wp_update_post( [ 'ID' => $data['form_id'], 'post_status' => 'publish', 'post_title' => $data['post_title'] ] );
         $existing_wpuf_input_ids = get_children( [
                                                      'post_parent' => $data['form_id'],
                                                      'post_status' => 'publish',
                                                      'post_type'   => 'wpuf_input',
                                                      'numberposts' => '-1',
                                                      'orderby'     => 'menu_order',
                                                      'order'       => 'ASC',
                                                      'fields'      => 'ids',
                                                  ] );
         $new_wpuf_input_ids = [];
         if ( ! empty( $data['form_fields'] ) ) {
@@ -517,21 +517,21 @@
             return $form_fields;
         }
 
-        // Built-in taxonomies that should always be available
-        $builtin_taxonomies = array( 'category', 'post_tag' );
+        // Get free taxonomies (built-in + ACF taxonomies)
+        $free_taxonomies = wpuf_get_free_taxonomies();
 
-        // Filter out custom taxonomy fields
+        // Filter out custom taxonomy fields (excluding ACF taxonomies)
         $filtered_fields = array();
 
         foreach ( $form_fields as $field ) {
-            // Skip custom taxonomy fields when pro is not active
+            // Skip custom taxonomy fields when pro is not active (but keep ACF taxonomies)
             if ( isset( $field['input_type'] ) && $field['input_type'] === 'taxonomy' ) {
-                if ( isset( $field['name'] ) && ! in_array( $field['name'], $builtin_taxonomies, true ) ) {
-                    continue; // Skip this custom taxonomy field
+                if ( isset( $field['name'] ) && ! in_array( $field['name'], $free_taxonomies, true ) ) {
+                    continue; // Skip this custom taxonomy field (not ACF)
                 }
             }
 
-            // Keep all other fields including built-in taxonomies
+            // Keep all other fields including built-in and ACF taxonomies
             $filtered_fields[] = $field;
         }
 
@@ -549,7 +549,8 @@
         if ( wpuf_is_pro_active() ) {
             return false;
         }
-        $builtin = [ 'category', 'post_tag' ];
+        // Get free taxonomies (built-in + ACF taxonomies)
+        $free_taxonomies = wpuf_get_free_taxonomies();
         $stack = is_array($original_fields) ? $original_fields : [];
         while ( $stack ) {
             $f = array_pop( $stack );
@@ -568,7 +569,7 @@
             }
             if ( isset( $f['input_type'] ) && $f['input_type'] === 'taxonomy' ) {
                 $slug = $f['name'] ?? ($f['taxonomy'] ?? null);
-                if ( $slug && ! in_array( $slug, $builtin, true ) ) {
+                if ( $slug && ! in_array( $slug, $free_taxonomies, true ) ) {
                     return true;
                 }
             }
@@ -590,7 +591,8 @@
         }
 
         $hidden_ids = array();
-        $builtin_taxonomies = array( 'category', 'post_tag' );
+        // Get free taxonomies (built-in + ACF taxonomies)
+        $free_taxonomies = wpuf_get_free_taxonomies();
 
         // Extract IDs from filtered fields for quick lookup
         $filtered_ids = array();
@@ -600,10 +602,10 @@
             }
         }
 
-        // Find original fields that are custom taxonomy fields and were filtered out
+        // Find original fields that are custom taxonomy fields and were filtered out (excluding ACF)
         foreach ( $original_fields as $field ) {
             if ( isset( $field['input_type'] ) && $field['input_type'] === 'taxonomy' ) {
-                if ( isset( $field['name'] ) && ! in_array( $field['name'], $builtin_taxonomies, true ) ) {
+                if ( isset( $field['name'] ) && ! in_array( $field['name'], $free_taxonomies, true ) ) {
                     if ( isset( $field['id'] ) && ! in_array( $field['id'], $filtered_ids, true ) ) {
                         $hidden_ids[] = $field['id'];
                     }

includes/Fields/Form_Field_Post_Taxonomy.php

@@ -47,11 +47,11 @@ public function __construct( $tax_name, $taxonomy, $post_id = null, $user_id = n
      * @return bool
      */
     public function is_pro() {
-        // Built-in WordPress taxonomies that are always available
-        $builtin_taxonomies = array( 'category', 'post_tag' );
+        // Get free taxonomies (built-in + ACF taxonomies)
+        $free_taxonomies = wpuf_get_free_taxonomies();
 
-        // If this is a custom taxonomy (not built-in) and pro is not active, treat it as a pro feature
-        if ( ! in_array( $this->tax_name, $builtin_taxonomies, true ) && ! wpuf_is_pro_active() ) {
+        // If this is a custom taxonomy (not built-in or ACF) and pro is not active, treat it as a pro feature
+        if ( ! in_array( $this->tax_name, $free_taxonomies, true ) && ! wpuf_is_pro_active() ) {
             return true;
         }
 
@@ -69,12 +69,12 @@ public function is_pro() {
      * @return void
      */
     public function render( $field_settings, $form_id, $type = 'post', $post_id = null ) {
-        // Check if this is a custom taxonomy and pro is not active
-        $builtin_taxonomies = array( 'category', 'post_tag' );
+        // Check if this is a custom taxonomy and pro is not active (excluding ACF taxonomies)
+        $free_taxonomies = wpuf_get_free_taxonomies();
         $taxonomy_name = isset( $field_settings['name'] ) ? $field_settings['name'] : $this->tax_name;
 
-        if ( ! in_array( $taxonomy_name, $builtin_taxonomies, true ) && ! wpuf_is_pro_active() ) {
-            // Don't render custom taxonomies on frontend when pro is not active
+        if ( ! in_array( $taxonomy_name, $free_taxonomies, true ) && ! wpuf_is_pro_active() ) {
+            // Don't render custom taxonomies on frontend when pro is not active (ACF taxonomies are allowed)
             return;
         }
 

includes/Render_Form.php

@@ -1340,9 +1340,9 @@ private function is_taxonomy_field_gated( $form_field ) {
             return false;
         }
 
-        // Check if this is a custom taxonomy
-        $builtin_taxonomies = apply_filters( 'wpuf_builtin_taxonomies_free', array( 'category', 'post_tag' ) );
-        return ! in_array( $form_field['name'], $builtin_taxonomies, true );
+        // Get free taxonomies (built-in + ACF taxonomies)
+        $free_taxonomies = wpuf_get_free_taxonomies();
+        return ! in_array( $form_field['name'], $free_taxonomies, true );
     }
 
     /**
@@ -1352,10 +1352,10 @@ private function is_taxonomy_field_gated( $form_field ) {
      * @param int|null $post_id
      */
     public function taxonomy( $attr, $post_id, $form_id ) {
-        // Check if this is a custom taxonomy and pro is not active
-        $builtin_taxonomies = apply_filters( 'wpuf_builtin_taxonomies_free', array( 'category', 'post_tag' ) );
-        if ( ! in_array( $attr['name'], $builtin_taxonomies, true ) && ! wpuf_is_pro_active() ) {
-            // Don't render custom taxonomies when pro is not active
+        // Check if this is a custom taxonomy and pro is not active (excluding ACF taxonomies)
+        $free_taxonomies = wpuf_get_free_taxonomies();
+        if ( ! in_array( $attr['name'], $free_taxonomies, true ) && ! wpuf_is_pro_active() ) {
+            // Don't render custom taxonomies when pro is not active (ACF taxonomies are allowed)
             return;
         }
 

wpuf-functions.php

@@ -5704,3 +5704,163 @@ function wpuf_field_profile_photo_allowed_mimes() {
         return apply_filters( 'wpuf_field_profile_photo_allowed_mimes', $profile_photo_mimes );
     }
 }
+
+/**
+ * Check if a taxonomy is registered by Advanced Custom Fields (ACF)
+ *
+ * ACF taxonomies should be available in the free version as they are user-created
+ * via ACF, not plugin-specific custom taxonomies.
+ *
+ * @since WPUF_SINCE
+ *
+ * @param string $taxonomy_name The taxonomy name to check
+ * @return bool True if taxonomy is registered by ACF, false otherwise
+ */
+if ( ! function_exists( 'wpuf_is_acf_taxonomy' ) ) {
+    function wpuf_is_acf_taxonomy( $taxonomy_name ) {
+        // If taxonomy doesn't exist, it can't be an ACF taxonomy
+        if ( ! taxonomy_exists( $taxonomy_name ) ) {
+            return false;
+        }
+
+        // Get the taxonomy object
+        $taxonomy = get_taxonomy( $taxonomy_name );
+
+        if ( ! $taxonomy ) {
+            return false;
+        }
+
+        // ACF taxonomies typically have these characteristics:
+        // 1. They are not built-in (_builtin = false)
+        // 2. They are registered by ACF (check for ACF-specific properties)
+
+        // Check if ACF is active
+        if ( ! class_exists( 'acf' ) ) {
+            return false;
+        }
+
+        // ACF stores taxonomy configuration in the database
+        // Check if there's an ACF post type that registered this taxonomy
+        global $wpdb;
+
+        // ACF saves custom taxonomies as posts of type 'acf-taxonomy'
+        // The taxonomy slug is stored in the serialized post_content, not post_name
+        // post_name is ACF's internal key like 'taxonomy_69242380c35d7'
+        $acf_taxonomies = $wpdb->get_results(
+            "SELECT post_content FROM {$wpdb->posts}
+            WHERE post_type = 'acf-taxonomy'
+            AND post_status = 'publish'"
+        );
+
+        if ( ! empty( $acf_taxonomies ) ) {
+            foreach ( $acf_taxonomies as $acf_tax ) {
+                // ACF stores the taxonomy configuration as serialized data
+                $config = maybe_unserialize( $acf_tax->post_content );
+
+                // Check if the taxonomy key matches our taxonomy name
+                if ( is_array( $config ) && isset( $config['taxonomy'] ) && $config['taxonomy'] === $taxonomy_name ) {
+                    return true;
+                }
+            }
+        }
+
+        // Additional check: ACF taxonomies often have 'acf' in their labels or registration
+        // Check if the taxonomy object has ACF-specific metadata
+        if ( isset( $taxonomy->acf ) || isset( $taxonomy->_builtin ) && ! $taxonomy->_builtin ) {
+            // Check if registered via ACF by looking for ACF functions
+            if ( function_exists( 'acf_get_internal_post_type' ) ) {
+                $internal_types = acf_get_internal_post_type( 'acf-taxonomy', 'names' );
+                if ( is_array( $internal_types ) && in_array( $taxonomy_name, $internal_types, true ) ) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}
+
+/**
+ * Get taxonomy object types (post types the taxonomy is associated with)
+ *
+ * This works for all taxonomies - built-in, custom, ACF, or any other.
+ *
+ * @since WPUF_SINCE
+ *
+ * @param string $taxonomy_name The taxonomy name to check
+ * @return array Array of post type names associated with the taxonomy
+ */
+if ( ! function_exists( 'wpuf_get_taxonomy_post_types' ) ) {
+    function wpuf_get_taxonomy_post_types( $taxonomy_name ) {
+        // If taxonomy doesn't exist, return empty array
+        if ( ! taxonomy_exists( $taxonomy_name ) ) {
+            return [];
+        }
+
+        // Get the taxonomy object
+        $taxonomy = get_taxonomy( $taxonomy_name );
+
+        if ( ! $taxonomy ) {
+            return [];
+        }
+
+        // WordPress stores associated post types in object_type property
+        if ( isset( $taxonomy->object_type ) && is_array( $taxonomy->object_type ) ) {
+            return $taxonomy->object_type;
+        }
+
+        return [];
+    }
+}
+
+/**
+ * Get list of taxonomies that should be available in free version
+ *
+ * This includes built-in taxonomies and ACF-registered taxonomies.
+ *
+ * @since WPUF_SINCE
+ *
+ * @return array Array of taxonomy names that are available in free version
+ */
+if ( ! function_exists( 'wpuf_get_free_taxonomies' ) ) {
+    function wpuf_get_free_taxonomies() {
+        // Built-in taxonomies that are always available
+        $free_taxonomies = array( 'category', 'post_tag' );
+
+        // Allow filtering to add more free taxonomies
+        //$free_taxonomies = apply_filters( 'wpuf_free_taxonomies', $free_taxonomies );
+
+        // Get all registered taxonomies (built-in and custom)
+        $all_taxonomies = get_taxonomies( array(), 'names' );
+
+        foreach ( $all_taxonomies as $taxonomy_name ) {
+            // Skip if already in free list
+            if ( in_array( $taxonomy_name, $free_taxonomies, true ) ) {
+                continue;
+            }
+
+            // Get the post types this taxonomy is associated with
+            $post_types = wpuf_get_taxonomy_post_types( $taxonomy_name );
+
+            // Only allow taxonomies that are associated with 'post' or 'page' in free version
+            if ( ! empty( $post_types ) ) {
+                $allowed_post_types = array( 'post', 'page' );
+                $has_allowed_type = false;
+
+                foreach ( $post_types as $post_type ) {
+                    if ( in_array( $post_type, $allowed_post_types, true ) ) {
+                        $has_allowed_type = true;
+                        break;
+                    }
+                }
+
+                // If this taxonomy is for post or page, add it to free list
+                if ( $has_allowed_type ) {
+                    $free_taxonomies[] = $taxonomy_name;
+                }
+            }
+        }
+
+        return $free_taxonomies;
+    }
+}