Process fields added using the 'kirki_fields' and 'kirki_controls' filter.
These filters are no longer used, this is simply for backwards-compatibility.

@access private
@since 2.0.0
768934
private function fields_from_filters() {
		$fields = apply_filters( 'kirki_controls', [] );
		$fields = apply_filters( 'kirki_fields', $fields );

		if ( ! empty( $fields ) ) {
			foreach ( $fields as $field ) {
				$field['kirki_config'] = 'global';
				Kirki::add_field( $field );
			}
		}
	}
988120
private void processProps() {
    ElementFilter
        .fieldsIn(component.getEnclosedElements())
        .stream()
        .filter(field -> hasAnnotation(field, Prop.class))
        .forEach(field -> {
          String propName = field.getSimpleName().toString();
          Prop prop = field.getAnnotation(Prop.class);

          collectionFieldsValidator.validateComponentPropField(field);

          fieldsWithNameExposed.add(new ExposedField(propName, field.asType()));

          optionsBuilder.addStatement(
              "options.addJavaProp($S, $T.getFieldName(this, () -> this.$L = $L), $L, $S)",
              propName,
              VueGWTTools.class,
              propName,
              getFieldMarkingValueForType(field.asType()),
              prop.required(),
              prop.checkType() ? getNativeNameForJavaType(field.asType()) : null
          );
        });
  }
657143
function clean_fields( $fields )
	{
		// trim down the fields
		if( $fields )
		{
			foreach( $fields as $i => $field )
			{
				// unset unneccessary bits
				unset( $field['id'], $field['class'], $field['order_no'], $field['field_group'], $field['_name'] );
				
				
				// instructions
				if( !$field['instructions'] )
				{
					unset( $field['instructions'] );
				}
				
				
				// Required
				if( !$field['required'] )
				{
					unset( $field['required'] );
				}
				
				
				// conditional logic
				if( !$field['conditional_logic']['status'] )
				{
					unset( $field['conditional_logic'] );
				}
				
				
				// children
				if( isset($field['sub_fields']) )
				{
					$field['sub_fields'] = apply_filters('acf/export/clean_fields', $field['sub_fields']);
				}
				elseif( isset($field['layouts']) )
				{
					foreach( $field['layouts'] as $l => $layout )
					{
						$field['layouts'][ $l ]['sub_fields'] = apply_filters('acf/export/clean_fields', $layout['sub_fields']);
					}
				}

				
				// override field
				$fields[ $i ] = $field;
			}
		}
		
		return $fields;
	}
751001
protected function process()
    {

        // query whether or not the media gallery has to be cleaned up
        if ($this->getSubject()->getConfiguration()->hasParam(ConfigurationKeys::CLEAN_UP_MEDIA_GALLERY) &&
            $this->getSubject()->getConfiguration()->getParam(ConfigurationKeys::CLEAN_UP_MEDIA_GALLERY)
        ) {
            // initialize the array for the actual images
            $actualImageNames = array();

            // iterate over the available image fields
            foreach (array_keys($this->getImageTypes()) as $imageColumnName) {
                if ($this->hasValue($imageColumnName) && !in_array($imageName = $this->getValue($imageColumnName), $actualImageNames)) {
                    $actualImageNames[] = $imageName;
                }
            }

            // query whether or not, we've additional images
            if ($additionalImages = $this->getValue(ColumnKeys::ADDITIONAL_IMAGES, null, array($this, 'explode'))) {
                foreach ($additionalImages as $additionalImageName) {
                    // do nothing if the image has already been added, e. g. it is the base image
                    if (in_array($additionalImageName, $actualImageNames)) {
                        continue;
                    }

                    // else, add the image to the array
                    $actualImageNames[] = $additionalImageName;
                }
            }

            // load the existing media gallery entities for the produdct with the given SKU
            $existingProductMediaGalleries = $this->getProductMediaProcessor()
                                                  ->getProductMediaGalleriesBySku($sku = $this->getValue(ColumnKeys::SKU));

            // remove the images that are NOT longer available in the CSV file
            foreach ($existingProductMediaGalleries as $existingProductMediaGallery) {
                // do nothing if the file still exists
                if (in_array($existingImageName = $existingProductMediaGallery[MemberNames::VALUE], $actualImageNames)) {
                    continue;
                }

                try {
                    // remove the old image from the database
                    $this->getProductMediaProcessor()
                         ->deleteProductMediaGallery(array(MemberNames::VALUE_ID => $existingProductMediaGallery[MemberNames::VALUE_ID]));

                    // log a debug message that the image has been removed
                    $this->getSubject()
                         ->getSystemLogger()
                         ->warning(
                             $this->getSubject()->appendExceptionSuffix(
                                 sprintf(
                                     'Successfully removed image "%s" from media gallery for product with SKU "%s"',
                                     $existingImageName,
                                     $sku
                                 )
                             )
                         );
                } catch (\Exception $e) {
                    // log a warning if debug mode has been enabled and the file is NOT available
                    if ($this->getSubject()->isDebugMode()) {
                        $this->getSubject()
                             ->getSystemLogger()
                             ->warning($this->getSubject()->appendExceptionSuffix($e->getMessage()));
                    } else {
                        throw $e;
                    }
                }
            }

            // log a message that the images has been cleaned-up
            $this->getSubject()
                 ->getSystemLogger()
                 ->debug(
                     $this->getSubject()->appendExceptionSuffix(
                         sprintf(
                             'Successfully cleaned-up media gallery for product with SKU "%s"',
                             $sku
                         )
                     )
                 );
        }
    }
1047278
public function populate_vars() {

		// Get an array of all fields.
		$fields = array_merge( Kirki::$fields, $this->fields );
		foreach ( $fields as $id => $args ) {
			if ( ! isset( $args['css_vars'] ) || empty( $args['css_vars'] ) ) {
				continue;
			}
			$val = Values::get_value( $args['kirki_config'], $id );
			foreach ( $args['css_vars'] as $css_var ) {
				if ( isset( $css_var[2] ) && is_array( $val ) && isset( $val[ $css_var[2] ] ) ) {
					$this->vars[ $css_var[0] ] = str_replace( '$', $val[ $css_var[2] ], $css_var[1] );
				} else {
					$this->vars[ $css_var[0] ] = str_replace( '$', $val, $css_var[1] );
				}
			}
		}
	}
937470
function addField( $attributes ) {
		if( isset( $attributes['NAME'] ) ) {
			$name = $attributes['NAME'];
		} else {
			$name = count($this->data[$this->row]);
		}

		// Set the field index so we know where we are
		$this->current_field = $this->FieldID( $name );
	}
124675
public function afterUpdate()
    {
        //only clean and change custom fields if they are been sent
        if (!empty($this->customFields)) {
            //replace old custom with new
            $allCustomFields = $this->getAllCustomFields();
            if (is_array($allCustomFields)) {
                foreach ($this->customFields as $key => $value) {
                    $allCustomFields[$key] = $value;
                }
            }

            //set
            $this->setCustomFields($allCustomFields);
            //clean old
            $this->cleanCustomFields($this->getId());
            //save new
            $this->saveCustomFields();
        }
    }
150489
public function process()
    {

        if ($this->plugin->request()->has('_flush')) {

            if ($this->flushCache($this->plugin->request()->get('_flush'))) {

                $this->attributes['alertClass'] = 'success';
                $this->attributes['messages'] = array(
                    '&#10004; ' . $this->plugin->config()->get('plugin.namespace') . ' ' . ucwords($this->plugin->request()->get('_flush')) . ' flushed successfully.'
                );
                //Refresh Data
            } else {

                $this->attributes['alertClass'] = 'error';
                $this->attributes['messages'] = array(
                    '&#9888; ' . $this->plugin->config()->get('plugin.namespace') . ' ' . ucwords($this->plugin->request()->get('_flush'))
                    .' could not be flushed.  The file(s) may not exist; If they exist, check directory structure, permissions and config paths.'
                );
            }

            $this->data();
        }

    }
42124
public function process($fields)
    {
        $data = array();
        foreach ($fields as $model) {
            $data[] = $this->row($model);
        }
        header('Content-Type: text/json');

        echo json_encode(array('data' => $data));
        die();
    }
823083
public function addFields(array $fields)
    {
        array_walk(
            $fields,
            function ($field, $key) {
                $this->addField($key, $field);
            }
        );
    }
377202
protected function composeFields()
    {
        $addFields = [];
        $updateFields = [];

        foreach ($this->entities as $entity) {
            if ($entity->id) {
                $updateFields[] = $entity->get();
            } else {
                $addFields[] = $entity->get();
            }
        }

        $this->fields['ACTION'] = 'ALL_EDIT';

        $fields = array_merge($addFields, $updateFields);

        if (count($fields)) {
            $this->fields['task_types'] = $fields;
        }
    }
1215093
protected function processPostFields()
    {
        if (!$this->postFiles) {
            $this->removeHeader('Expect')->setHeader('Content-Type', self::URL_ENCODED);
        } else {
            $this->setHeader('Content-Type', self::MULTIPART);
            if ($this->expectCutoff !== false) {
                $this->setHeader('Expect', '100-Continue');
            }
        }
    }
649646
protected function process()
    {

        // initialize the array for the links
        $artefacts = array();

        // load the email with the column keys of the customer-address CSV file
        $email = $this->getValue(\TechDivision\Import\Customer\Utils\ColumnKeys::EMAIL);

        $artefacts[] = $this->newArtefact(
            array(
                ColumnKeys::ENTITY_ID                => null,
                ColumnKeys::EMAIL                    => $email,
                ColumnKeys::WEBSITE                  => $this->getValue(ColumnKeys::WEBSITE),
                ColumnKeys::CITY                     => $this->getValue(ColumnKeys::ADDRESS_CITY),
                ColumnKeys::COMPANY                  => $this->getValue(ColumnKeys::ADDRESS_COMPANY),
                ColumnKeys::COUNTRY_ID               => $this->getValue(ColumnKeys::ADDRESS_COUNTRY_ID),
                ColumnKeys::FAX                      => $this->getValue(ColumnKeys::ADDRESS_FAX),
                ColumnKeys::FIRSTNAME                => $this->getValue(ColumnKeys::ADDRESS_FIRSTNAME),
                ColumnKeys::LASTNAME                 => $this->getValue(ColumnKeys::ADDRESS_LASTNAME),
                ColumnKeys::MIDDLENAME               => $this->getValue(ColumnKeys::ADDRESS_MIDDLENAME),
                ColumnKeys::POSTCODE                 => $this->getValue(ColumnKeys::ADDRESS_POSTCODE),
                ColumnKeys::PREFIX                   => $this->getValue(ColumnKeys::ADDRESS_PREFIX),
                ColumnKeys::REGION                   => $this->getValue(ColumnKeys::ADDRESS_REGION),
                ColumnKeys::STREET                   => $this->getValue(ColumnKeys::ADDRESS_STREET),
                ColumnKeys::SUFFIX                   => $this->getValue(ColumnKeys::ADDRESS_SUFFIX),
                ColumnKeys::TELEPHONE                => $this->getValue(ColumnKeys::ADDRESS_TELEPHONE),
                ColumnKeys::VAT_ID                   => $this->getValue(ColumnKeys::ADDRESS_VAT_ID),
                ColumnKeys::ADDRESS_DEFAULT_BILLING  => $this->getValue(ColumnKeys::ADDRESS_DEFAULT_BILLING),
                ColumnKeys::ADDRESS_DEFAULT_SHIPPING => $this->getValue(ColumnKeys::ADDRESS_DEFAULT_SHIPPING)
            ),
            array(
                ColumnKeys::ENTITY_ID                => null,
                ColumnKeys::WEBSITE                  => ColumnKeys::WEBSITE,
                ColumnKeys::EMAIL                    => ColumnKeys::EMAIL,
                ColumnKeys::CITY                     => ColumnKeys::ADDRESS_CITY,
                ColumnKeys::COMPANY                  => ColumnKeys::ADDRESS_COMPANY,
                ColumnKeys::COUNTRY_ID               => ColumnKeys::ADDRESS_COUNTRY_ID,
                ColumnKeys::FAX                      => ColumnKeys::ADDRESS_FAX,
                ColumnKeys::FIRSTNAME                => ColumnKeys::ADDRESS_FIRSTNAME,
                ColumnKeys::LASTNAME                 => ColumnKeys::ADDRESS_LASTNAME,
                ColumnKeys::MIDDLENAME               => ColumnKeys::ADDRESS_MIDDLENAME,
                ColumnKeys::POSTCODE                 => ColumnKeys::ADDRESS_POSTCODE,
                ColumnKeys::PREFIX                   => ColumnKeys::ADDRESS_PREFIX,
                ColumnKeys::REGION                   => ColumnKeys::ADDRESS_REGION,
                ColumnKeys::STREET                   => ColumnKeys::ADDRESS_STREET,
                ColumnKeys::SUFFIX                   => ColumnKeys::ADDRESS_SUFFIX,
                ColumnKeys::TELEPHONE                => ColumnKeys::ADDRESS_TELEPHONE,
                ColumnKeys::VAT_ID                   => ColumnKeys::ADDRESS_VAT_ID,
                ColumnKeys::ADDRESS_DEFAULT_BILLING  => ColumnKeys::ADDRESS_DEFAULT_BILLING,
                ColumnKeys::ADDRESS_DEFAULT_SHIPPING => ColumnKeys::ADDRESS_DEFAULT_SHIPPING
            )
        );

        // append the links to the subject
        $this->addArtefacts($artefacts);
    }
1294146
protected function process()
    {

        // add the path => entity ID/store view code mapping
        $this->addPathEntityIdMapping($path = $this->getValue(ColumnKeys::PATH));
        $this->addPathStoreViewCodeMapping($path, $this->getSubject()->getStoreViewCode(StoreViewCodes::ADMIN));

        // temporary persist the path
        $this->setLastPath($path);
    }
348779
public function postmessage() {
		wp_enqueue_script( 'kirki_auto_css_vars', URL::get_from_path( __DIR__ . '/script.js' ), [ 'jquery', 'customize-preview' ], KIRKI_VERSION, true );
		$fields = array_merge( Kirki::$fields, $this->fields );
		$data   = [];
		foreach ( $fields as $field ) {
			if ( isset( $field['transport'] ) && 'postMessage' === $field['transport'] && isset( $field['css_vars'] ) && ! empty( $field['css_vars'] ) ) {
				$data[] = $field;
			}
		}
		wp_localize_script( 'kirki_auto_css_vars', 'kirkiCssVarFields', $data );
	}
844548
protected function _saveSortingFieldValuesOnLoad()
    {
        $aSortingFields = \OxidEsales\Eshop\Core\Registry::getConfig()->getConfigParam('aSortCols');
        $aSortingFields = !empty($aSortingFields) ? (array) $aSortingFields : [];

        foreach ($aSortingFields as $sField) {
            $sFullField = $this->_getFieldLongName($sField);
            $this->_aSortingFieldsOnLoad[$sFullField] = $this->$sFullField->value;
        }
    }
528195
public function applyFilters()
    {
        if ($this->filters) {
            foreach ($this->filters as $k => $filter) {
                if (
                    isset($_GET[$filter['field']]) &&
                    !empty($_GET[$filter['field']]) &&
                    $_GET[$filter['field']] != $this->filterEmpty &&
                    @$_GET['filter'] != $filter['field']
                ) {
                    $this->model->addCondition($filter['field'], $_GET[$filter['field']]);
                }
            }
        }
    }