<?php # src/Acme/RangeBundle/Product/Value/RangeValue.php

namespace Acme\RangeBundle\Product\Value;

use Akeneo\Pim\Enrichment\Component\Product\Model\AbstractValue;
use Akeneo\Pim\Enrichment\Component\Product\Model\ValueInterface;

class RangeValue extends AbstractValue
{
    public function isEqual(ValueInterface $value) : bool
    {
        return $value instanceof RangeValue && $value->getData() === $this->getData();
    }

    public function getData()
    {
        return $this->data;
    }

    public function __toString() : string
    {
        return sprintf('[%s...%s]', $this->data['min'] ?? '', $this->data['max'] ?? '');
    }
}

<?php # src/Acme/RangeBundle/Product/Factory/Value/RangeValueFactory.php

namespace Acme\RangeBundle\Product\Factory\Value;

use Acme\RangeBundle\AttributeType\RangeType;
use Acme\RangeBundle\Product\Value\RangeValue;
use Akeneo\Pim\Enrichment\Component\Product\Factory\Value\ValueFactory;
use Akeneo\Pim\Enrichment\Component\Product\Model\ValueInterface;
use Akeneo\Pim\Structure\Component\Query\PublicApi\AttributeType\Attribute;
use Akeneo\Tool\Component\StorageUtils\Exception\InvalidPropertyException;
use Akeneo\Tool\Component\StorageUtils\Exception\InvalidPropertyTypeException;

class RangeValueFactory implements ValueFactory
{
    public function createByCheckingData(
        Attribute $attribute,
        ?string $channelCode,
        ?string $localeCode,
        $data
    ): ValueInterface {
        if (!is_array($data)) {
            throw InvalidPropertyTypeException::arrayExpected(
                $attribute->code(),
                static::class,
                $data
            );
        }

        if (!isset($data['min'])) {
            throw InvalidPropertyTypeException::arrayKeyExpected(
                $attribute->code(),
                'min',
                static::class,
                $data
            );
        }

        if (null === $data['min'] && null === $data['max']) {
            throw InvalidPropertyException::valueNotEmptyExpected(
                $attribute->code(),
                static::class
            );
        }

        if (!isset($data['max'])) {
            throw InvalidPropertyTypeException::arrayKeyExpected(
                $attribute->code(),
                'max',
                static::class,
                $data
            );
        }

        return $this->createWithoutCheckingData($attribute, $channelCode, $localeCode, $data);
    }

    public function createWithoutCheckingData(Attribute $attribute, ?string $channelCode, ?string $localeCode, $data): ValueInterface
    {
        if ($attribute->isLocalizableAndScopable()) {
            return RangeValue::scopableLocalizableValue($attribute->code(), $data, $channelCode, $localeCode);
        }
        if ($attribute->isScopable()) {
            return RangeValue::scopableValue($attribute->code(), $data, $channelCode);
        }
        if ($attribute->isLocalizable()) {
            return RangeValue::localizableValue($attribute->code(), $data, $localeCode);
        }

        return RangeValue::value($attribute->code(), $data);
    }

    public function supportedAttributeType(): string
    {
        return RangeType::RANGE;
    }
}