Enhanced PHP File Manager

⬆️ Go Up (..)

📊 Server Information

Server:

LiteSpeed

System:

Linux 4.18.0-553.84.1.lve.el8.x86_64

PHP Version:

8.2.30

User:

u176134211

Directory:

/home/u176134211/domains/api.teamhydrashop.com/public_html/vendor/spatie/opening-hours/src

Free Space:

8.14 TB

🔧 Quick Actions

✏️ Editing: OpeningHours.php

<?php

namespace Spatie\OpeningHours;

use DateTime;
use DateTimeImmutable;
use DateTimeInterface;
use DateTimeZone;
use Generator;
use Spatie\OpeningHours\Exceptions\Exception;
use Spatie\OpeningHours\Exceptions\InvalidDate;
use Spatie\OpeningHours\Exceptions\InvalidDateTimeClass;
use Spatie\OpeningHours\Exceptions\InvalidDayName;
use Spatie\OpeningHours\Exceptions\InvalidTimezone;
use Spatie\OpeningHours\Exceptions\MaximumLimitExceeded;
use Spatie\OpeningHours\Exceptions\SearchLimitReached;
use Spatie\OpeningHours\Helpers\Arr;
use Spatie\OpeningHours\Helpers\DataTrait;
use Spatie\OpeningHours\Helpers\DateTimeCopier;
use Spatie\OpeningHours\Helpers\DiffTrait;

class OpeningHours
{
    const DEFAULT_DAY_LIMIT = 8;

use DataTrait, DateTimeCopier, DiffTrait;

/** @var \Spatie\OpeningHours\OpeningHoursForDay[] */
    protected $openingHours = [];

/** @var \Spatie\OpeningHours\OpeningHoursForDay[] */
    protected $exceptions = [];

/** @var callable[] */
    protected $filters = [];

/** @var DateTimeZone|null */
    protected $timezone = null;

/** @var DateTimeZone|null */
    protected $outputTimezone = null;

/** @var bool Allow for overflowing time ranges which overflow into the next day */
    protected $overflow;

/** @var int Number of days to try before abandoning the search of the next close/open time */
    protected $dayLimit = null;

/** @var string */
    protected $dateTimeClass = DateTime::class;

/**
     * @param  string|DateTimeZone|null  $timezone
     * @param  string|DateTimeZone|null  $outputTimezone
     */
    public function __construct($timezone = null, $outputTimezone = null)
    {
        $this->setTimezone($timezone);
        $this->setOutputTimezone($outputTimezone);

$this->openingHours = Day::mapDays(static function () {
            return new OpeningHoursForDay();
        });
    }

/**
     * @param  array{
     *             monday?: array<string|array>,
     *             tuesday?: array<string|array>,
     *             wednesday?: array<string|array>,
     *             thursday?: array<string|array>,
     *             friday?: array<string|array>,
     *             saturday?: array<string|array>,
     *             sunday?: array<string|array>,
     *             exceptions?: array<array<string|array>>,
     *             filters?: callable[],
     *             overflow?: bool,
     *         }                         $data
     * @param  string|DateTimeZone|null  $timezone
     * @param  string|DateTimeZone|null  $outputTimezone
     * @return static
     */
    public static function create(array $data, $timezone = null, $outputTimezone = null): self
    {
        return (new static($timezone, $outputTimezone))->fill($data);
    }

/**
     * @param  array  $data  hours definition array or sub-array
     * @param  array  $excludedKeys  keys to ignore from parsing
     * @return array
     */
    public static function mergeOverlappingRanges(array $data, array $excludedKeys = ['data', 'filters', 'overflow'])
    {
        $result = [];
        $ranges = [];

foreach (static::filterHours($data, $excludedKeys) as $key => $value) {
            $value = is_array($value)
                ? static::mergeOverlappingRanges($value, ['data'])
                : (is_string($value) ? TimeRange::fromString($value) : $value);

if ($value instanceof TimeRange) {
                $newRanges = [];

foreach ($ranges as $range) {
                    if ($value->format() === $range->format()) {
                        continue 2;
                    }

if ($value->overlaps($range) || $range->overlaps($value)) {
                        $value = TimeRange::fromList([$value, $range]);

continue;
                    }

$newRanges[] = $range;
                }

$newRanges[] = $value;
                $ranges = $newRanges;

continue;
            }

$result[$key] = $value;
        }

foreach ($ranges as $range) {
            $result[] = $range;
        }

return $result;
    }

/**
     * @param  array{
     *             monday?: array<string|array>,
     *             tuesday?: array<string|array>,
     *             wednesday?: array<string|array>,
     *             thursday?: array<string|array>,
     *             friday?: array<string|array>,
     *             saturday?: array<string|array>,
     *             sunday?: array<string|array>,
     *             exceptions?: array<array<string|array>>,
     *             filters?: callable[],
     *             overflow?: bool,
     *         }                         $data
     * @param  string|DateTimeZone|null  $timezone
     * @param  string|DateTimeZone|null  $outputTimezone
     * @return static
     */
    public static function createAndMergeOverlappingRanges(array $data, $timezone = null, $outputTimezone = null)
    {
        return static::create(static::mergeOverlappingRanges($data), $timezone, $outputTimezone);
    }

/**
     * @param  array  $data
     * @return bool
     */
    public static function isValid(array $data): bool
    {
        try {
            static::create($data);

return true;
        } catch (Exception $exception) {
            return false;
        }
    }

/**
     * Select the class to use to create new date-time instances.
     *
     * @param  string|null  $dateTimeClass
     * @return $this
     *
     * @throws InvalidDateTimeClass if $dateTimeClass is set with a string that is not a valid DateTimeInterface.
     */
    public function setDateTimeClass(string $dateTimeClass = null)
    {
        if ($dateTimeClass !== null && ! is_a($dateTimeClass, DateTimeInterface::class, true)) {
            throw InvalidDateTimeClass::forString($dateTimeClass);
        }

$this->dateTimeClass = $dateTimeClass ?? DateTime::class;

return $this;
    }

/**
     * Set the number of days to try before abandoning the search of the next close/open time.
     *
     * @param  int  $dayLimit  number of days
     * @return $this
     */
    public function setDayLimit(int $dayLimit)
    {
        $this->dayLimit = $dayLimit;

return $this;
    }

/**
     * Get the number of days to try before abandoning the search of the next close/open time.
     *
     * @return int
     */
    public function getDayLimit(): int
    {
        return $this->dayLimit ?: static::DEFAULT_DAY_LIMIT;
    }

public function setFilters(array $filters)
    {
        $this->filters = $filters;

return $this;
    }

public function getFilters(): array
    {
        return $this->filters;
    }

public function fill(array $data)
    {
        $timezones = array_key_exists('timezone', $data) ? $data['timezone'] : [];
        unset($data['timezone']);

if (! is_array($timezones)) {
            $timezones = ['input' => $timezones];
        }

if (array_key_exists('input', $timezones)) {
            $this->timezone = $this->parseTimezone($timezones['input']);
        }

if (array_key_exists('output', $timezones)) {
            $this->outputTimezone = $this->parseTimezone($timezones['output']);
        }

list($openingHours, $exceptions, $metaData, $filters, $overflow, $dateTimeClass) = $this
            ->parseOpeningHoursAndExceptions($data);

$this->overflow = $overflow;

foreach ($openingHours as $day => $openingHoursForThisDay) {
            $this->setOpeningHoursFromStrings($day, $openingHoursForThisDay);
        }

$this->setExceptionsFromStrings($exceptions);

return $this->setDateTimeClass($dateTimeClass)->setFilters($filters)->setData($metaData);
    }

public function forWeek(): array
    {
        return $this->openingHours;
    }

public function forWeekCombined(): array
    {
        $equalDays = [];
        $allOpeningHours = $this->openingHours;
        $uniqueOpeningHours = array_unique($allOpeningHours);
        $nonUniqueOpeningHours = $allOpeningHours;

foreach ($uniqueOpeningHours as $day => $value) {
            $equalDays[$day] = ['days' => [$day], 'opening_hours' => $value];
            unset($nonUniqueOpeningHours[$day]);
        }

foreach ($uniqueOpeningHours as $uniqueDay => $uniqueValue) {
            foreach ($nonUniqueOpeningHours as $nonUniqueDay => $nonUniqueValue) {
                if ((string) $uniqueValue === (string) $nonUniqueValue) {
                    $equalDays[$uniqueDay]['days'][] = $nonUniqueDay;
                }
            }
        }

return $equalDays;
    }

public function forWeekConsecutiveDays(): array
    {
        $concatenatedDays = [];
        $allOpeningHours = $this->openingHours;
        foreach ($allOpeningHours as $day => $value) {
            $previousDay = end($concatenatedDays);
            if ($previousDay && (string) $previousDay['opening_hours'] === (string) $value) {
                $key = key($concatenatedDays);
                $concatenatedDays[$key]['days'][] = $day;
                continue;
            }

$concatenatedDays[$day] = [
                'opening_hours' => $value,
                'days' => [$day],
            ];
        }

return $concatenatedDays;
    }

public function forDay(string $day): OpeningHoursForDay
    {
        $day = $this->normalizeDayName($day);

return $this->openingHours[$day];
    }

public function forDate(DateTimeInterface $date): OpeningHoursForDay
    {
        $date = $this->applyTimezone($date);

foreach ($this->filters as $filter) {
            $result = $filter($date);

if (is_array($result)) {
                return OpeningHoursForDay::fromStrings($result);
            }
        }

return $this->exceptions[$date->format('Y-m-d')] ?? ($this->exceptions[$date->format('m-d')] ?? $this->forDay(Day::onDateTime($date)));
    }

/**
     * @param  DateTimeInterface  $date
     * @return TimeRange[]
     */
    public function forDateTime(DateTimeInterface $date): array
    {
        $date = $this->applyTimezone($date);

return array_merge(
            iterator_to_array($this->forDate(
                $this->yesterday($date)
            )->forNightTime(Time::fromDateTime($date))),
            iterator_to_array($this->forDate($date)->forTime(Time::fromDateTime($date)))
        );
    }

public function exceptions(): array
    {
        return $this->exceptions;
    }

public function isOpenOn(string $day): bool
    {
        if (preg_match('/^(?:(\d+)-)?(\d{1,2})-(\d{1,2})$/', $day, $match)) {
            list(, $year, $month, $day) = $match;
            $year = $year ?: date('Y');

return count($this->forDate(new DateTimeImmutable("$year-$month-$day", $this->timezone))) > 0;
        }

return count($this->forDay($day)) > 0;
    }

public function isClosedOn(string $day): bool
    {
        return ! $this->isOpenOn($day);
    }

public function isOpenAt(DateTimeInterface $dateTime): bool
    {
        $dateTime = $this->applyTimezone($dateTime);

if ($this->overflow) {
            $dateTimeMinus1Day = $this->yesterday($dateTime);
            $openingHoursForDayBefore = $this->forDate($dateTimeMinus1Day);
            if ($openingHoursForDayBefore->isOpenAtNight(PreciseTime::fromDateTime($dateTimeMinus1Day))) {
                return true;
            }
        }

$openingHoursForDay = $this->forDate($dateTime);

return $openingHoursForDay->isOpenAt(PreciseTime::fromDateTime($dateTime));
    }

public function isClosedAt(DateTimeInterface $dateTime): bool
    {
        return ! $this->isOpenAt($dateTime);
    }

public function isOpen(): bool
    {
        return $this->isOpenAt(new $this->dateTimeClass());
    }

public function isClosed(): bool
    {
        return $this->isClosedAt(new $this->dateTimeClass());
    }

public function currentOpenRange(DateTimeInterface $dateTime)
    {
        $dateTime = $this->applyTimezone($dateTime);
        $list = $this->forDateTime($dateTime);

return end($list) ?: false;
    }

public function currentOpenRangeStart(DateTimeInterface $dateTime)
    {
        $outputTimezone = $this->getOutputTimezone($dateTime);
        $dateTime = $this->applyTimezone($dateTime);
        /** @var TimeRange $range */
        $range = $this->currentOpenRange($dateTime);

if (! $range) {
            return false;
        }

$dateTime = $this->copyDateTime($dateTime);

$nextDateTime = $range->start()->toDateTime();

if ($range->overflowsNextDay() && $nextDateTime->format('Hi') > $dateTime->format('Hi')) {
            $dateTime = $dateTime->modify('-1 day');
        }

return $this->getDateWithTimezone(
            $dateTime->setTime($nextDateTime->format('G'), $nextDateTime->format('i'), 0),
            $outputTimezone
        );
    }

public function currentOpenRangeEnd(DateTimeInterface $dateTime)
    {
        $outputTimezone = $this->getOutputTimezone($dateTime);
        $dateTime = $this->applyTimezone($dateTime);
        /** @var TimeRange $range */
        $range = $this->currentOpenRange($dateTime);

if (! $range) {
            return false;
        }

$dateTime = $this->copyDateTime($dateTime);

$nextDateTime = $range->end()->toDateTime();

if ($range->overflowsNextDay() && $nextDateTime->format('Hi') < $dateTime->format('Hi')) {
            $dateTime = $dateTime->modify('+1 day');
        }

return $this->getDateWithTimezone(
            $dateTime->setTime($nextDateTime->format('G'), $nextDateTime->format('i'), 0),
            $outputTimezone
        );
    }

public function nextOpen(
        DateTimeInterface $dateTime = null,
        DateTimeInterface $searchUntil = null,
        DateTimeInterface $cap = null
    ): DateTimeInterface {
        $outputTimezone = $this->getOutputTimezone($dateTime);
        $dateTime = $this->applyTimezone($dateTime ?? new $this->dateTimeClass());
        $dateTime = $this->copyDateTime($dateTime);
        $openingHoursForDay = $this->forDate($dateTime);
        $nextOpen = $openingHoursForDay->nextOpen(PreciseTime::fromDateTime($dateTime));
        $tries = $this->getDayLimit();

while ($nextOpen === false || $nextOpen->hours() >= 24) {
            if (--$tries < 0) {
                throw MaximumLimitExceeded::forString(
                    'No open date/time found in the next '.$this->getDayLimit().' days,'.
                    ' use $openingHours->setDayLimit() to increase the limit.'
                );
            }

$dateTime = $dateTime
                ->modify('+1 day')
                ->setTime(0, 0, 0);

if ($this->isOpenAt($dateTime) && ! $openingHoursForDay->isOpenAt(Time::fromString('23:59'))) {
                return $this->getDateWithTimezone($dateTime, $outputTimezone);
            }

if ($cap && $dateTime > $cap) {
                return $cap;
            }

if ($searchUntil && $dateTime > $searchUntil) {
                throw SearchLimitReached::forDate($searchUntil);
            }

$openingHoursForDay = $this->forDate($dateTime);

$nextOpen = $openingHoursForDay->nextOpen(PreciseTime::fromDateTime($dateTime));
        }

if ($dateTime->format('H:i') === '00:00' && $this->isOpenAt((clone $dateTime)->modify('-1 second'))) {
            return $this->getDateWithTimezone(
                $this->nextOpen($dateTime->modify('+1 minute')),
                $outputTimezone
            );
        }

$nextDateTime = $nextOpen->toDateTime();

return $this->getDateWithTimezone(
            $dateTime->setTime($nextDateTime->format('G'), $nextDateTime->format('i'), 0),
            $outputTimezone
        );
    }

public function nextClose(
        DateTimeInterface $dateTime = null,
        DateTimeInterface $searchUntil = null,
        DateTimeInterface $cap = null
    ): DateTimeInterface {
        $outputTimezone = $this->getOutputTimezone($dateTime);
        $dateTime = $this->applyTimezone($dateTime ?? new $this->dateTimeClass());
        $dateTime = $this->copyDateTime($dateTime);
        $nextClose = null;

if ($this->overflow) {
            $dateTimeMinus1Day = $this->copyDateTime($dateTime)->modify('-1 day');
            $openingHoursForDayBefore = $this->forDate($dateTimeMinus1Day);

if ($openingHoursForDayBefore->isOpenAtNight(PreciseTime::fromDateTime($dateTimeMinus1Day))) {
                $nextClose = $openingHoursForDayBefore->nextClose(PreciseTime::fromDateTime($dateTime));
            }
        }

$openingHoursForDay = $this->forDate($dateTime);

if (! $nextClose) {
            $nextClose = $openingHoursForDay->nextClose(PreciseTime::fromDateTime($dateTime));

if ($nextClose && $nextClose->hours() < 24 && $nextClose->format('Gi') < $dateTime->format('Gi')) {
                $dateTime = $dateTime->modify('+1 day');
            }
        }

$tries = $this->getDayLimit();

while ($nextClose === false || $nextClose->hours() >= 24) {
            if (--$tries < 0) {
                throw MaximumLimitExceeded::forString(
                    'No close date/time found in the next '.$this->getDayLimit().' days,'.
                    ' use $openingHours->setDayLimit() to increase the limit.'
                );
            }

$dateTime = $dateTime
                ->modify('+1 day')
                ->setTime(0, 0, 0);

if ($this->isClosedAt($dateTime) && $openingHoursForDay->isOpenAt(Time::fromString('23:59'))) {
                return $this->getDateWithTimezone($dateTime, $outputTimezone);
            }

if ($cap && $dateTime > $cap) {
                return $cap;
            }

if ($searchUntil && $dateTime > $searchUntil) {
                throw SearchLimitReached::forDate($searchUntil);
            }

$openingHoursForDay = $this->forDate($dateTime);

$nextClose = $openingHoursForDay->nextClose(PreciseTime::fromDateTime($dateTime));
        }

$nextDateTime = $nextClose->toDateTime();

return $this->getDateWithTimezone(
            $dateTime->setTime($nextDateTime->format('G'), $nextDateTime->format('i'), 0),
            $outputTimezone
        );
    }

public function previousOpen(
        DateTimeInterface $dateTime,
        DateTimeInterface $searchUntil = null,
        DateTimeInterface $cap = null
    ): DateTimeInterface {
        $outputTimezone = $this->getOutputTimezone($dateTime);
        $dateTime = $this->copyDateTime($this->applyTimezone($dateTime));
        $openingHoursForDay = $this->forDate($dateTime);
        $previousOpen = $openingHoursForDay->previousOpen(PreciseTime::fromDateTime($dateTime));
        $tries = $this->getDayLimit();

while ($previousOpen === false || ($previousOpen->hours() === 0 && $previousOpen->minutes() === 0)) {
            if (--$tries < 0) {
                throw MaximumLimitExceeded::forString(
                    'No open date/time found in the previous '.$this->getDayLimit().' days,'.
                    ' use $openingHours->setDayLimit() to increase the limit.'
                );
            }

$midnight = $dateTime->setTime(0, 0, 0);
            $dateTime = clone $midnight;
            $dateTime = $dateTime->modify('-1 minute');

$openingHoursForDay = $this->forDate($dateTime);

if ($this->isOpenAt($midnight) && ! $openingHoursForDay->isOpenAt(Time::fromString('23:59'))) {
                return $this->getDateWithTimezone($midnight, $outputTimezone);
            }

if ($cap && $dateTime < $cap) {
                return $cap;
            }

if ($searchUntil && $dateTime < $searchUntil) {
                throw SearchLimitReached::forDate($searchUntil);
            }

$previousOpen = $openingHoursForDay->previousOpen(PreciseTime::fromDateTime($dateTime));
        }

$nextDateTime = $previousOpen->toDateTime();

return $this->getDateWithTimezone(
            $dateTime->setTime($nextDateTime->format('G'), $nextDateTime->format('i'), 0),
            $outputTimezone
        );
    }

public function previousClose(
        DateTimeInterface $dateTime,
        DateTimeInterface $searchUntil = null,
        DateTimeInterface $cap = null
    ): DateTimeInterface {
        $outputTimezone = $this->getOutputTimezone($dateTime);
        $dateTime = $this->copyDateTime($this->applyTimezone($dateTime));
        $previousClose = null;
        if ($this->overflow) {
            $dateTimeMinus1Day = $this->copyDateTime($dateTime)->modify('-1 day');
            $openingHoursForDayBefore = $this->forDate($dateTimeMinus1Day);
            if ($openingHoursForDayBefore->isOpenAtNight(PreciseTime::fromDateTime($dateTimeMinus1Day))) {
                $previousClose = $openingHoursForDayBefore->previousClose(PreciseTime::fromDateTime($dateTime));
            }
        }

$openingHoursForDay = $this->forDate($dateTime);
        if (! $previousClose) {
            $previousClose = $openingHoursForDay->previousClose(PreciseTime::fromDateTime($dateTime));
        }

$tries = $this->getDayLimit();

while ($previousClose === false || ($previousClose->hours() === 0 && $previousClose->minutes() === 0)) {
            if (--$tries < 0) {
                throw MaximumLimitExceeded::forString(
                    'No close date/time found in the previous '.$this->getDayLimit().' days,'.
                    ' use $openingHours->setDayLimit() to increase the limit.'
                );
            }

$midnight = $dateTime->setTime(0, 0, 0);
            $dateTime = clone $midnight;
            $dateTime = $dateTime->modify('-1 minute');
            $openingHoursForDay = $this->forDate($dateTime);

if ($this->isClosedAt($midnight) && $openingHoursForDay->isOpenAt(Time::fromString('23:59'))) {
                return $this->getDateWithTimezone($midnight, $outputTimezone);
            }

if ($cap && $dateTime < $cap) {
                return $cap;
            }

if ($searchUntil && $dateTime < $searchUntil) {
                throw SearchLimitReached::forDate($searchUntil);
            }

$previousClose = $openingHoursForDay->previousClose(PreciseTime::fromDateTime($dateTime));
        }

$previousDateTime = $previousClose->toDateTime();

return $this->getDateWithTimezone(
            $dateTime->setTime($previousDateTime->format('G'), $previousDateTime->format('i'), 0),
            $outputTimezone
        );
    }

public function regularClosingDays(): array
    {
        return array_keys($this->filter(static function (OpeningHoursForDay $openingHoursForDay) {
            return $openingHoursForDay->isEmpty();
        }));
    }

public function regularClosingDaysISO(): array
    {
        return Arr::map($this->regularClosingDays(), [Day::class, 'toISO']);
    }

public function exceptionalClosingDates(): array
    {
        $dates = array_keys($this->filterExceptions(static function (OpeningHoursForDay $openingHoursForDay) {
            return $openingHoursForDay->isEmpty();
        }));

return Arr::map($dates, static function ($date) {
            return DateTime::createFromFormat('Y-m-d', $date);
        });
    }

/**
     * @param  string|DateTimeZone|null  $timezone
     * @return void
     */
    public function setTimezone($timezone)
    {
        $this->timezone = $this->parseTimezone($timezone);
    }

/**
     * @param  string|DateTimeZone|null  $timezone
     * @return void
     */
    public function setOutputTimezone($timezone)
    {
        $this->outputTimezone = $this->parseTimezone($timezone);
    }

protected function parseOpeningHoursAndExceptions(array $data): array
    {
        $dateTimeClass = Arr::pull($data, 'dateTimeClass', null);
        $metaData = Arr::pull($data, 'data', null);
        $exceptions = [];
        $filters = Arr::pull($data, 'filters', []);
        $overflow = (bool) Arr::pull($data, 'overflow', false);

foreach (Arr::pull($data, 'exceptions', []) as $key => $exception) {
            if (is_callable($exception)) {
                $filters[] = $exception;

continue;
            }

$exceptions[$key] = $exception;
        }

$openingHours = [];

foreach ($data as $day => $openingHoursData) {
            $openingHours[$this->normalizeDayName($day)] = $openingHoursData;
        }

return [$openingHours, $exceptions, $metaData, $filters, $overflow, $dateTimeClass];
    }

protected function setOpeningHoursFromStrings(string $day, array $openingHours)
    {
        $day = $this->normalizeDayName($day);

$data = null;

if (isset($openingHours['data'])) {
            $data = $openingHours['data'];
            unset($openingHours['data']);
        }

$this->openingHours[$day] = OpeningHoursForDay::fromStrings($openingHours)->setData($data);
    }

protected function setExceptionsFromStrings(array $exceptions)
    {
        if (empty($exceptions)) {
            return;
        }

if (! $this->dayLimit) {
            $this->dayLimit = 366;
        }

$this->exceptions = Arr::map($exceptions, static function (array $openingHours, string $date) {
            $recurring = DateTime::createFromFormat('m-d', $date);

if ($recurring === false || $recurring->format('m-d') !== $date) {
                $dateTime = DateTime::createFromFormat('Y-m-d', $date);

if ($dateTime === false || $dateTime->format('Y-m-d') !== $date) {
                    throw InvalidDate::invalidDate($date);
                }
            }

return OpeningHoursForDay::fromStrings($openingHours);
        });
    }

protected function normalizeDayName(string $day)
    {
        $day = strtolower($day);

if (! Day::isValid($day)) {
            throw InvalidDayName::invalidDayName($day);
        }

return $day;
    }

protected function applyTimezone(DateTimeInterface $date)
    {
        return $this->getDateWithTimezone($date, $this->timezone);
    }

/**
     * @param  DateTimeInterface  $date
     * @param  DateTimeZone|null  $timezone
     * @return DateTimeInterface
     */
    protected function getDateWithTimezone(DateTimeInterface $date, $timezone)
    {
        if ($timezone) {
            if ($date instanceof DateTime) {
                $date = clone $date;
            }

$date = $date->setTimezone($timezone);
        }

return $date;
    }

public function filter(callable $callback): array
    {
        return Arr::filter($this->openingHours, $callback);
    }

public function map(callable $callback): array
    {
        return Arr::map($this->openingHours, $callback);
    }

public function flatMap(callable $callback): array
    {
        return Arr::flatMap($this->openingHours, $callback);
    }

public function filterExceptions(callable $callback): array
    {
        return Arr::filter($this->exceptions, $callback);
    }

public function mapExceptions(callable $callback): array
    {
        return Arr::map($this->exceptions, $callback);
    }

public function flatMapExceptions(callable $callback): array
    {
        return Arr::flatMap($this->exceptions, $callback);
    }

public function asStructuredData(string $format = 'H:i', $timezone = null): array
    {
        $regularHours = $this->flatMap(static function (OpeningHoursForDay $openingHoursForDay, string $day) use ($format, $timezone) {
            return $openingHoursForDay->map(static function (TimeRange $timeRange) use ($format, $timezone, $day) {
                return [
                    '@type' => 'OpeningHoursSpecification',
                    'dayOfWeek' => ucfirst($day),
                    'opens' => $timeRange->start()->format($format, $timezone),
                    'closes' => $timeRange->end()->format($format, $timezone),
                ];
            });
        });

$exceptions = $this->flatMapExceptions(static function (OpeningHoursForDay $openingHoursForDay, string $date) use ($format, $timezone) {
            if ($openingHoursForDay->isEmpty()) {
                $zero = Time::fromString('00:00')->format($format, $timezone);

return [[
                    '@type' => 'OpeningHoursSpecification',
                    'opens' => $zero,
                    'closes' => $zero,
                    'validFrom' => $date,
                    'validThrough' => $date,
                ]];
            }

return $openingHoursForDay->map(static function (TimeRange $timeRange) use ($format, $date, $timezone) {
                return [
                    '@type' => 'OpeningHoursSpecification',
                    'opens' => $timeRange->start()->format($format, $timezone),
                    'closes' => $timeRange->end()->format($format, $timezone),
                    'validFrom' => $date,
                    'validThrough' => $date,
                ];
            });
        });

return array_merge($regularHours, $exceptions);
    }

private static function filterHours(array $data, array $excludedKeys): Generator
    {
        foreach ($data as $key => $value) {
            if (in_array($key, $excludedKeys, true)) {
                continue;
            }

if (is_int($key) && is_array($value) && isset($value['hours'])) {
                foreach ((array) $value['hours'] as $subKey => $hour) {
                    yield "$key.$subKey" => $hour;
                }

continue;
            }

yield $key => $value;
        }
    }

/**
     * @param  mixed  $timezone
     * @return DateTimeZone|null
     */
    private function parseTimezone($timezone)
    {
        if ($timezone instanceof DateTimeZone) {
            return $timezone;
        }

if (is_string($timezone)) {
            return new DateTimeZone($timezone);
        }

if ($timezone) {
            throw InvalidTimezone::create();
        }

return null;
    }

/**
     * @param  DateTimeInterface|null  $dateTime
     * @return DateTimeZone|null
     */
    private function getOutputTimezone(DateTimeInterface $dateTime = null)
    {
        if ($this->outputTimezone !== null) {
            return $this->outputTimezone;
        }

if ($this->timezone === null || $dateTime === null) {
            return $this->timezone;
        }

return $dateTime->getTimezone();
    }
}

❌ Cancel

🗂️ Enhanced PHP File Manager

📊 Server Information

🔧 Quick Actions

✏️ Editing: OpeningHours.php

📤 Upload File

📁 Create Folder

📄 Create File

✏️ Rename Item

🗑️ Delete Confirmation