function generateButtons(buttons) {
    // get the dataset value
    let uniqueCategories = [...new Set()];

    buttons.forEach((button) => {
      const category = button.dataset.category;
      uniqueCategories.push(category);
    });

    uniqueCategories = uniqueCategories.filter(function (item, pos) {
      return uniqueCategories.indexOf(item) == pos;
    });

    uniqueCategories.unshift("All");

    console.log(uniqueCategories);

    // return ` <button type="button" class="filter-btn" data-id="${category}">${category}</button>`;
  }

[
    {
        "$match": {
            "authorization": {
                "$ne": null
            }
        }
    },
    {
        "$match": {
            "email": {
                "$not": {
                    "$regularExpression": {
                        "pattern": "deleted",
                        "options": ""
                    }
                }
            }
        }
    },
 
    {
        "$lookup": {
            "from": "participant",
            "localField": "email",
            "foreignField": "email",
            "as": "userParticipant"
        }
    },
    {
        "$match": {}
    },
    {
        "$lookup": {
            "from": "masterSlot",
            "localField": "userParticipant._id",
            "foreignField": "navigatorId",
            "as": "slots"
        }
    },
    {
        "$lookup": {
            "from": "userCoachMapping",
            "localField": "userParticipant._id",
            "foreignField": "coachID",
            "as": "userCoachMapping"
        }
    },
    {
        "$project": {
        
            "isCoachActive": {
                "$arrayElemAt": [
                    "$userParticipant.active",
                    0
                ]
            },
        
            "email": {
                "$arrayElemAt": [
                    "$userParticipant.email",
                    0
                ]
            },
            "firstName": {
                "$arrayElemAt": [
                    "$userParticipant.firstName",
                    0
                ]
            },
            "coachProfileDescription": {
                "$arrayElemAt": [
                    "$userParticipant.coachProfileDescription",
                    0
                ]
            },
    
            "middleName": {
                "$arrayElemAt": [
                    "$userParticipant.middleName",
                    0
                ]
            },
            "lastName": {
                "$arrayElemAt": [
                    "$userParticipant.lastName",
                    0
                ]
            },
            "partnerShortCode": {
                "$arrayElemAt": [
                    "$userParticipant.partnerShortCode",
                    0
                ]
            },
    
            "role": {
                "$arrayElemAt": [
                    "$userParticipant.role",
                    0
                ]
            },
            "templateName": "$authorization.name",
            "servicePartnerShortCode": "$servicePartnerShortCode",
            "userVisibility": "$userVisibility",
    
            "Total Users": {
                "$size": {
                    "$filter": {
                        "input": "$userCoachMapping",
                        "as": "coach",
                        "cond": { "$eq": ["$$coach.userStatus", "ACTIVE"] }
                    }
                }
            }
            _id:0
        }
    },
    {
        $match:{
            "Total Users": { "$gt": 0 }
        }
    }
]

 https://gist.github.com/aalexandr21/23794f7473a46de2e024a2542afb3155

I added it here https://prnt.sc/5Oc1TgkXsaGc
And to listings that you need to hide, I added the CSS class hide_when_use_filter https://prnt.sc/XaE35kAG5Ddp

/**Snippet**/


jQuery(document).ready(function ($) {
    document.addEventListener('jet-smart-filters/inited', function (initEvent) {
        JetSmartFilters.events.subscribe('activeItems/change', function (activeItems) {
            if (activeItems && activeItems.length >= 1) {
                $(".hide_when_use_filter").slideUp();
            }
            else {
                $(".hide_when_use_filter").slideDown();
            };
        });
    })
});

<style>

    body:not(.elementor-editor-active) .hide-listing {
        display: none;
        height: 0;
    }
    
</style>

<script>

	document.addEventListener( 'jet-smart-filters/inited', function( initEvent ) {
		
		function hideProvider( $provider, parentSelector ) {
			$provider.closest( parentSelector ).addClass( 'hide-listing' );
		}
		
		function showProvider( $provider, parentSelector ) {
			$provider.closest( parentSelector ).removeClass( 'hide-listing' );
		}
		
		jQuery( function( $ ) {
			
			for ( const groupName in window.JetSmartFilters.filterGroups ) {
				
				const filterGroup = window.JetSmartFilters.filterGroups[ groupName ],
				      $provider   = filterGroup?.$provider,
				      query       = filterGroup?.currentQuery || {};
					
				if ( ! $provider.closest('.hide-before-filter')?.length ) {
					return;
				}
				
				if ( ! Object.keys( query ).length ) {
					hideProvider( $provider, '.hide-before-filter' );
				} else {
					showProvider( $provider, '.hide-before-filter' );
				}
				
			}
			
			window.JetSmartFilters.events.subscribe( 'ajaxFilters/updated', function( provider, queryId ) {
				
				const filterGroup = window.JetSmartFilters.filterGroups[ provider + '/' + queryId ],
				      $provider   = filterGroup.$provider,
				      query       = filterGroup.currentQuery || {};
				
				if ( ! Object.keys( query ).length ) {
					hideProvider( $provider, '.hide-before-filter.hide-on-reset' );
				} else {
					showProvider( $provider, '.hide-before-filter' );
				}
				
			} );
		
		} );
	
	} );
	
</script>

[
    {
        "$match": {
            "startDate": {
                "$gte": {
                    "$date": "2018-03-12T03:26:21.997Z"
                },
                "$lte": {
                    "$date": "2024-03-10T04:50:35Z"
                }
            }
        }
    },
    {
        "$lookup": {
            "from": "participant",
            "localField": "userId",
            "foreignField": "_id",
            "as": "participantData"
        }
    },
    {
        "$unwind": "$participantData"
    },
    {
        "$match": {
            "participantData.email": {
                "$regularExpression": {
                    "pattern": "@jiva.user",
                    "options": ""
                }
            }
        }
    },
    {
        "$match": {
            "participantData.userStatus": {
                "$ne": "TEST"
            }
        }
    },
    {
        "$match": {
            "$and": [
                {
                    "participantData.email": {
                        "$not": {
                            "$regularExpression": {
                                "pattern": "deleted",
                                "options": ""
                            }
                        }
                    }
                },
                {
                    "participantData.email": {
                        "$not": {
                            "$regularExpression": {
                                "pattern": "@smit\\.fit$",
                                "options": ""
                            }
                        }
                    }
                }
            ]
        }
    },
    {
        "$lookup": {
            "from": "participantBaselineAndFollowupData",
            "localField": "userId",
            "foreignField": "participantId",
            "as": "baselineData"
        }
    },
    {
        "$unwind": "$baselineData"
    },
    {
        "$lookup": {
            "from": "blood_glucose",
            "localField": "userId",
            "foreignField": "participantId",
            "as": "glucoseData"
        }
    },
    {
        "$unwind": "$glucoseData\", \"preserveNullAndEmptyArrays\" : true}"
    },
    {
        "$project": {
            "subscriptionId": "$_id",
            "baselineId": "$baselineData._id",
            "userId": 1,
            "startDate": 1,
            "programStartDate": "$baselineData.programStartDate",
            "planCode1": "$subscriptionPlan.programCode",
            "journeyStatus": "$journeyTrackerObject.status",
            "planCode2": "$baselineData.programCode",
            "followUps": "$baselineData.followUps",
            "glucoseData": 1
        }
    },
    {
        "$match": {
            "$and": [
                {
                    "$expr": {
                        "$and": [
                            {
                                "$eq": [
                                    "$planCode1",
                                    "$planCode2"
                                ]
                            },
                            {
                                "$eq": [
                                    "$startDate",
                                    "$programStartDate"
                                ]
                            }
                        ]
                    }
                }
            ]
        }
    },
    {
        "$group": {
            "_id": {
                "userId": "$userId",
                "startDate": "$startDate",
                "planCode1": "$planCode1"
            },
            "userId": {
                "$last": "$userId"
            },
            "baselineId": {
                "$last": "$baselineId"
            },
            "startDate": {
                "$last": "$startDate"
            },
            "programStartDate": {
                "$last": "$programStartDate"
            },
            "subscriptionId": {
                "$last": "$subscriptionId"
            },
            "journeyStatus": {
                "$last": "$journeyStatus"
            },
            "followUps": {
                "$last": "$followUps"
            },
            "glucoseData": {
                "$push": "$glucoseData"
            }
        }
    },
    {
        "$project": {
            "userId": 1,
            "baselineId": 1,
            "startDate": 1,
            "programStartDate": 1,
            "subscriptionId": 1,
            "journeyStatus": 1,
            "followUps": 1,
            "field": {
                "$add": [
                    "$_id.startDate",
                    {
                        "$multiply": [
                            14,
                            24,
                            60,
                            60,
                            1000
                        ]
                    }
                ]
            },
            "glucoseData": {
                "$filter": {
                    "input": "$glucoseData",
                    "as": "glucose",
                    "cond": {
                        "$and": [
                            {
                                "$lt": [
                                    "$$glucose.date",
                                    {
                                        "$add": [
                                            "$_id.startDate",
                                            {
                                                "$multiply": [
                                                    14,
                                                    24,
                                                    60,
                                                    60,
                                                    1000
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "$gte": [
                                    "$$glucose.date",
                                    "$_id.startDate"
                                ]
                            }
                        ]
                    }
                }
            }
        }
    },
    {
        "$project": {
            "userId": 1,
            "baselineId": 1,
            "startDate": 1,
            "programStartDate": 1,
            "subscriptionId": 1,
            "journeyStatus": 1,
            "followUps": 1,
            "glucoseData": {
                "$map": {
                    "input": "$glucoseData",
                    "as": "obj",
                    "in": {
                        "participantId": "$$obj.participantId",
                        "reading": "$$obj.reading",
                        "date": "$$obj.date"
                    }
                }
            }
        }
    }
]

  // Derived state. These are the posts that will actually be displayed
  const searchedPosts = searchQuery.length > 0 ? posts.filter((post) => `${post.title} ${post.body}`.toLowerCase().includes(searchQuery.toLowerCase())) : posts;

function filterAndCheckValue(array, valueToCheck) {
  const filteredArray = array.filter(item => item === valueToCheck);

  if (filteredArray.length === 0) {
    return array;
  }

  return filteredArray;
}

const myArray = [1, 2, 3, 4, 5];
const valueToFind = 6;

const result = filterAndCheckValue(myArray, valueToFind);
console.log(result); // Output: [1, 2, 3, 4, 5]

function example_return_select_label ($field_selector, $post_id) {
	$field = get_field_object($field_selector, $post_id);

	$choices = $field['choices'];
	$value = $field['value'];

	if ( isset($choices[$value]) ) {
		return $choices[$value];
	}
}


// Example usage (https://d.pr/i/Xj7DQ3):
//[example_return_select_label("field_6247468a6a53a",{ID})]

const friends = [
  { name: "Abby", age: 22 },
  { name: "Boby", age: 16 },
  { name: "Coel", age: 20 },
  { name: "Dany", age: 15 }
];

//who can drink?
friends.filter(friend => friend.age >= 18);

//get list of buttons and make sure there are no duplicates

function displayButtons(){
    const companies = products.reduce((total, item) => {
       total.push(item.company)
       total = [...new Set(total)]
       return total
    },['All'])
 
    const buttons = companies.map((item) => {
       return `<button class="company-btn">${item}</button>`
    }).join('')
 
    buttonsContainer.innerHTML = buttons
 
 }


 // or we could do this...
 const someBtns = ['all',...new Set(products.map((product) => product.company)),];  
  console.log(someBtns)

<?php

add_filter( 'acf/validate_value/name=property_size', 'validate_property_size_field', 10, 4 );

function validate_property_size_field( $valid, $value, $field, $input ){

  // bail early if value is already invalid
  if ( ! $valid ) { return $valid; }

  $property_type = $_POST['acf']['field_5f0aa92348bb6'];

  if ( $property_type == 'Rent' ){
    if ( ! $value ) {
      $valid = __( 'This field is required for Rental Properties' );
    }
  }

  return $valid;

}

Sort(Filter('YouTube Resources', Text(Created,"mm/dd/yyyy") = Text(Today(),"mm/dd/yyyy")), Created,Descending)

Set(currentUser, User()); //require for the on start property

Set(varFirstName, Trim(Last(FirstN(Split(currentUser.FullName," "), 1)).Result))

CheckOutFrom eq '@{formatDateTime(utcNow(), 'yyyy-MM-dd')}'

/**
*   WooCommerce woocommerce_order_item_line_item_html action hook registeration.
*/
add_action('woocommerce_order_item_line_item_html', 'woocommerce_order_item_line_item_html', 1, 3);


/**
* Callback Listener for customised line item functionality in the admin.
*/
function woocommerce_order_item_line_item_html($item_id, $item, $order){
    // Add your custom line item functionality.
    // A good example would be order fulfillment for a line item.
}

add_filter( 'woocommerce_product_get_stock_quantity' ,'custom_get_stock_quantity', 10, 2 );
add_filter( 'woocommerce_product_variation_get_stock_quantity' ,'custom_get_stock_quantity', 10, 2 );
function custom_get_stock_quantity( $value, $product ) {
    $value = 15; // <== Just for testing
    return $value;
}

To Filter Model Array:

var filteredItems = unfilteredItems.filter { $0.cat == "garden" }

Arrange :

self.chatModelArray = self.chatModelArray.sorted { $0.time == $1.time }

To Filter name : 

var filteredItems = unfilteredItems.filter { $0.name.localizedCaseInsensitiveContains(textField.text ?? "") }

To Filter an Array:

let result = arr.filter {$0.contains("ali")}

Get-Service | Where-Object -FilterScript {$_.StartType -EQ 'Automatic'}

import React from 'react';

const people = [
  {
    name: 'James',
    age: 31,
  },
  {
    name: 'John',
    age: 45,
  },
  {
    name: 'Paul',
    age: 65,
  },
  {
    name: 'Ringo',
    age: 49,
  },
  {
    name: 'George',
    age: 34,
  }
];

function App() {
  return (
    <div>
      {people.filter(person => person.age < 60).map(filteredPerson => (
        <li>
          {filteredPerson.name}
        </li>
      ))}
    </div>
  );
}

export default App;

import React from 'react';

const names = ['James', 'John', 'Paul', 'Ringo', 'George'];

function App() {
  return (
    <div>
      {names.filter(name => name.includes('J')).map(filteredName => (
        <li>
          {filteredName}
        </li>
      ))}
    </div>
  );
}

export default App;

c3 = pd.Series(['China', 'US'])
df[df['countries'].isin(c1)]

# applying filter function 
df.filter(["Name", "College", "Salary"]) 

# importing pandas as pd 
import pandas as pd 
  
# Creating the dataframe  
df = pd.read_csv("nba.csv") 
  
# Using regular expression to extract all 
# columns which has letter 'a' or 'A' in its name. 
df.filter(regex ='[aA]')