Computed field should specify the cardinality of the field

Ah yes, I hadn't thought of that! Fields by default are single-valued, but the rendering system is lazy and just iterates anyway.

1. +++ b/computed_field.module
   @@ -121,6 +121,12 @@ function computed_field_entity_base_field_info_alter(&$fields, EntityTypeInterfa
   +    if ($plugin->fieldIsMultiple()) {
   

   same.

2. +++ b/computed_field.module
   @@ -177,6 +183,12 @@ function computed_field_entity_bundle_field_info_alter(&$fields, EntityTypeInter
   +    if ($plugin->fieldIsMultiple()) {
   

   We don't need this check - just pass on the cardinality, whatever it is.

3. +++ b/src/Annotation/ComputedField.php
   @@ -61,4 +62,12 @@ class ComputedField extends Plugin {
   +  public $cardinality = FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED;
   

   I'm not sure we should default to unlimited, as BaseFieldDefinition defaults to 1. We should be consistent.

4. +++ b/src/Plugin/ComputedField/ComputedFieldBase.php
   @@ -43,6 +44,21 @@ abstract class ComputedFieldBase extends PluginBase implements ComputedFieldPlug
   +    return $this->pluginDefinition['cardinality'] ?: FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED;
   

   You don't need the default here. It will come from the annotation property's default value if not specified in the plugin annotation.

5. +++ b/src/Plugin/ComputedField/ComputedFieldBase.php
   @@ -43,6 +44,21 @@ abstract class ComputedFieldBase extends PluginBase implements ComputedFieldPlug
   +    $cardinality = $this->getFieldCardinality();
   +    return ($cardinality === FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED) || ($cardinality > 1);
   

   It's simpler to just say != 1 here I think?

6. +++ b/src/Plugin/ComputedField/ComputedFieldPluginInterface.php
   @@ -54,6 +54,21 @@ interface ComputedFieldPluginInterface extends PluginInspectionInterface, Deriva
   +   * Returns whether the field is multiple or not
   

   Missing full stop.

Changes regarding #4, not sure on point 3.
Thanks

Not sure if this is related, but I get errors importing nodes in feeds if they would return multiple values when calculated.

"Keywords (computed_keywords): Keywords: this field cannot hold more than 1 values."

This field does hold more than one value just fine, and displays as multiple throughout the site, but, it breaks my feeds from importing...

namespace Drupal\monomaly_computed_fields\Plugin\ComputedField;

use Drupal\Core\Cache\CacheableMetadata;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\computed_field\Field\ComputedFieldDefinitionWithValuePluginInterface;
use Drupal\computed_field\Plugin\ComputedField\ComputedFieldBase;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\computed_field\Field\ComputedFieldSettingsTrait;

/**
 * @ComputedField(
 *   id = "monomaly_keywords_aggregator",
 *   label = @Translation("Keywords Aggregator"),
 *   field_type = "text",
 *   no_ui = FALSE,
 *   multiple_values = TRUE
 * )
 */
class SumUniqueKeywords extends ComputedFieldBase{

  /**
   * {@inheritdoc}
   */
   
  public function getFieldDefinitionSettings(): array {
    return [
        'cardinality' => BaseFieldDefinition::CARDINALITY_UNLIMITED,
    ];
  }


  // This is the method 
public function computeValue(EntityInterface $host_entity, ComputedFieldDefinitionWithValuePluginInterface $computed_field_definition): array {
    // Initialize the keywords count array and level texts.
    $keywords_count = [];
    $keywords_levels = [];

    // Iterate over all entity reference fields on the host entity, looking for taxonomy terms.
    foreach ($host_entity->getFieldDefinitions() as $field_definition) {
        if ($field_definition->getType() === 'entity_reference' &&
            $field_definition->getSetting('target_type') === 'taxonomy_term') {
            // Collect referenced taxonomy term entities.
            $referenced_terms = $host_entity->get($field_definition->getName())->referencedEntities();

            foreach ($referenced_terms as $term) {
                // Drill down into each referenced term to see if it has a keywords field.
                if ($term instanceof EntityInterface && $term->hasField('field_keywords')) {
                    // Get keyword terms from this term.
                    $keyword_terms = $term->get('field_keywords')->referencedEntities();

                    foreach ($keyword_terms as $keyword_term) {
                        // Count occurrences of each keyword.
                        $keyword_name = $keyword_term->getName();
                        if (!isset($keywords_count[$keyword_name])) {
                            $keywords_count[$keyword_name] = 0;
                            // Initialize the levels text for this keyword.
                            $keywords_levels[$keyword_name] = [
                                'level_1' => $keyword_term->field_level_1->value ?? '',
                                'level_2' => $keyword_term->field_level_2->value ?? '',
                                'level_3' => $keyword_term->field_level_3->value ?? '',
                            ];
                        }
                        $keywords_count[$keyword_name]++;
                    }
                }
            }
        }
    }

    // Set the computed values with level texts.
    $items = [];
    foreach ($keywords_count as $keyword_name => $count) {
        // Append level text based on count to the keyword.
        $level_text = '';
        if ($count == 1) {
            $level_text = $keywords_levels[$keyword_name]['level_1'];
        } elseif ($count == 2) {
            $level_text = $keywords_levels[$keyword_name]['level_2'];
        } elseif ($count >= 3) {
            $level_text = $keywords_levels[$keyword_name]['level_3'];
        }
        $output = "$keyword_name $count: $level_text";
        $items[] = $output;
    }

    // Debugging output.
    \Drupal::logger('monomaly_computed_fields')->info('Computed Field Debug: ' . print_r($items, TRUE));

    return $items;
    }
}

@roxflame I think cardinality was supposed to go in your plugin's getFieldCardinality(), not in getFieldDefinitionSettings

Could this be related to #3437020: Allow computed function callbacks to determine cardinality dynamically?

> 3. I chose the unlimited instead of 1 because the module "default plugin logic" is a unlimited value field.
> The "single" value needs to specify SingleValueTrait. But this is a mine arbitrary idea, it seems sensible to choose "1" as default.

The plugin logic was a mistake on my part -- I hadn't checked what base fields and config fields do.

We're still in alpha releases, so it's fine to change our API.

> Could this be related to #3437020: Allow computed function callbacks to determine cardinality dynamically?

Yes, they seem similar. Though I don't really understand the patch over there. Let's get this one in first.

Made a few changes, added a test.

Committed the MR.