Transformer.php

<?php
namespace modules\appmodule\services;

use aelvan\imager\Imager;
use Craft;
use craft\base\Element;
use craft\elements\Asset;
use craft\elements\db\ElementQuery;
use craft\elements\db\MatrixBlockQuery;
use craft\elements\Entry;
use craft\elements\User;
use craft\fields\data\MultiOptionsFieldData;
use craft\fields\data\OptionData;
use craft\models\EntryType;
use craft\models\Section;
use ether\simplemap\models\Map;
use modules\appmodule\transformers\ElementTransformer;
use modules\appmodule\transformers\EntryTransformer;
use Tightenco\Collect\Support\Collection;
use yii\base\Component;
use yii\db\QueryInterface;

class Transformer extends Component
{
    public function transformSingleOptionFieldData(OptionData $data): Collection
    {
        return Collection::make($data)->only('label', 'value');
    }

    public function transformMultiOptionsFieldData(MultiOptionsFieldData $data): Collection
    {
        return Collection::make($data->getOptions())
        ->filter(function ($item) {
            return $item->selected;
        })
        ->map(function ($item) {
            return $this->transformSingleOptionFieldData($item);
        })
        ->values();
    }

    public function structureToMenuHierarchy(ElementQuery $elementQuery): Collection
    {
        $elements = Collection::make($elementQuery->orderBy(['level' => SORT_ASC])->all())
        ->map(function ($element) {
            $rootElement = $element->getAncestors()->one() ?? $element;

            return Collection::make($element)
                ->only(['level', 'title', 'id'])
                ->put('rootId', $rootElement->id);
        });

        return $elements
        ->groupBy('level')
        ->keys()
        ->flatMap(function ($level) use ($elements) {
            $crumbs = $elements
                ->where('level', '<=', $level)
                ->groupBy('rootId')
                ->values()
                ->map(function ($item) {
                    return $item->pluck('title')->join(' > ');
                });

            $key = implode('', ['lvl', $level  -1]);

            return [
                $key => $crumbs,
            ];
        });
    }

    public function transformValue($value)
    {
        if ($value instanceof \DateTime) {
            return $value->getTimestamp();
        } elseif ($value instanceof RedactorFieldData) {
            return (string) $value;
        } elseif ($value instanceof MultiOptionsFieldData) {
            return $this->transformMultiOptionsFieldData($value);
        } elseif ($value instanceof SingleOptionFieldData) {
            return $this->transformSingleOptionFieldData($value);
        } elseif ($value instanceof Map) {
            if (!$value->lat && !$value->lng) {
                return Collection::make([]);
            }

            return Collection::make($value)->only([
                'lat',
                'lng',
            ])
            ->map(function ($value) {
                return floatval($value);
            });
        } elseif ($value instanceof User) {
            return Collection::make($value)
                ->only([
                    'id',
                    'username',
                ])
                ->put('profileURI', $value->getProfileUri());
        } elseif ($value instanceof Asset) {
            $transformed = Imager::getInstance()->imager->transformImage($value, [

                // Forces Imager to create focal point params
                'mode' => 'crop'
            ], null);

            return Collection::make($value)
                ->only([
                    'imgAltText',
                ])
                ->put('url', $transformed->url)
            ;
        } elseif ($value instanceof Entry) {
            return (new EntryTransformer)->transform($value);
        } elseif ($value instanceof Element) {
            return (new ElementTransformer)->transform($value);
        } elseif ($value instanceof Section || $value instanceof EntryType) {
            return Collection::make($value)
                ->only([
                    'name',
                    'handle',
                ]);
        } elseif ($value instanceof QueryInterface) {
            return $this->queryToCollection($value);
        }

        return $value;
    }

    public function queryToCollection(?QueryInterface $query): Collection
    {
        return Collection::make($query ? $query->all() : null);
    }

    public function transformValues($values): Collection
    {
        return Collection::make($this->transformValue($values))->map(function ($value) {
            return (is_iterable($value)) ?
                $this->transformValues($value) :
                $this->transformValue($value);
        });
    }

    public function getCoordsFromMatrix(MatrixBlockQuery $query, string $fieldHandle): Collection
    {
        return Collection::make($query->all())
            ->pluck($fieldHandle)
            ->map(function ($value) {
                return $this->transformValue($value);
            });
    }
}