Final Class Yiisoft\Form\Field\DateTimeLocal

                final public function addContainerAttributes(array $attributes): static
{
    $new = clone $this;
    $new->containerAttributes = array_merge($new->containerAttributes, $attributes);
    return $new;
}

            

                final public function addContainerClass(?string ...$class): static
{
    $new = clone $this;
    Html::addCssClass($new->containerAttributes, $class);
    return $new;
}

            

                final public function addErrorAttributes(array $attributes): static
{
    $new = clone $this;
    $new->errorAttributes = array_merge($new->errorAttributes, $attributes);
    return $new;
}

            

                final public function addErrorClass(?string ...$class): static
{
    $new = clone $this;
    Html::addCssClass($new->errorAttributes, $class);
    return $new;
}

            

                final public function addHintAttributes(array $attributes): static
{
    $new = clone $this;
    $new->hintAttributes = array_merge($new->hintAttributes, $attributes);
    return $new;
}

            

                final public function addHintClass(?string ...$class): static
{
    $new = clone $this;
    Html::addCssClass($new->hintAttributes, $class);
    return $new;
}

            

                final public function addInputAttributes(array $attributes): static
{
    $new = clone $this;
    $new->inputAttributes = array_merge($new->inputAttributes, $attributes);
    return $new;
}

            

                final public function addInputClass(?string ...$class): static
{
    $new = clone $this;
    Html::addCssClass($new->inputAttributes, $class);
    return $new;
}

            

                final public function addInputContainerAttributes(array $attributes): static
{
    $new = clone $this;
    $new->inputContainerAttributes = array_merge($new->inputContainerAttributes, $attributes);
    return $new;
}

            

                final public function addInputContainerClass(?string ...$class): static
{
    $new = clone $this;
    Html::addCssClass($new->inputContainerAttributes, $class);
    return $new;
}

            

                protected function addInputValidationClassToAttributes(
    array &$attributes,
    InputDataInterface $inputData,
    ?bool $hasCustomError = null,
): void {
    $this->addClassesToAttributes(
        $attributes,
        $inputData,
        $hasCustomError,
        $this->inputInvalidClass,
        $this->inputValidClass,
    );
}

            

                final public function addLabelAttributes(array $attributes): static
{
    $new = clone $this;
    $new->labelAttributes = array_merge($new->labelAttributes, $attributes);
    return $new;
}

            

                final public function addLabelClass(?string ...$class): static
{
    $new = clone $this;
    Html::addCssClass($new->labelAttributes, $class);
    return $new;
}

            

                protected function addValidationClassToAttributes(
    array &$attributes,
    InputDataInterface $inputData,
    ?bool $hasCustomError = null,
): void {
    $this->addClassesToAttributes(
        $attributes,
        $inputData,
        $hasCustomError,
        $this->invalidClass,
        $this->validClass,
    );
}

            

                final public function afterInput(string|Stringable $content): static
{
    $new = clone $this;
    $new->afterInput = $content;
    return $new;
}

            

                final public function ariaDescribedBy(?string ...$value): static
{
    $new = clone $this;
    $new->inputAttributes['aria-describedby'] = array_filter($value, static fn (?string $v): bool => $v !== null);
    return $new;
}

            

                final public function ariaLabel(?string $value): static
{
    $new = clone $this;
    $new->inputAttributes['aria-label'] = $value;
    return $new;
}

            

                final public function autofocus(bool $value = true): static
{
    $new = clone $this;
    $new->inputAttributes['autofocus'] = $value;
    return $new;
}

            

                final public function beforeInput(string|Stringable $content): static
{
    $new = clone $this;
    $new->beforeInput = $content;
    return $new;
}

            

                protected function beforeRender(): void
{
    if ($this->enrichFromValidationRules) {
        $this->enrichment = $this
            ->validationRulesEnricher
            ?->process($this, $this->getInputData()->getValidationRules())
            ?? [];
    }
}

            

                final public function begin(): ?string
{
    parent::begin();
    $this->isStartedByBegin = true;
    $this->beforeRender();
    $content = $this->generateBeginContent();
    return $this->renderOpenContainerAndContent($content);
}

            

                final public function containerAttributes(array $attributes): static
{
    $new = clone $this;
    $new->containerAttributes = $attributes;
    return $new;
}

            

                final public function containerClass(?string ...$class): static
{
    $new = clone $this;
    $new->containerAttributes['class'] = array_filter($class, static fn ($c) => $c !== null);
    return $new;
}

            

                final public function containerId(?string $id): static
{
    $new = clone $this;
    $new->containerAttributes['id'] = $id;
    return $new;
}

            

                final public function containerTag(string $tag): static
{
    if ($tag === '') {
        throw new InvalidArgumentException('Tag name cannot be empty.');
    }
    $new = clone $this;
    $new->containerTag = $tag;
    return $new;
}

            

                final public function disabled(bool $disabled = true): static
{
    $new = clone $this;
    $new->inputAttributes['disabled'] = $disabled;
    return $new;
}

            

                public function enrichFromValidationRules(bool $enrich = true): self
{
    $new = clone $this;
    $new->enrichFromValidationRules = $enrich;
    return $new;
}

            

                final public function error(?string $message, string ...$messages): static
{
    $new = clone $this;
    $new->errorConfig['message()'] = [$message, ...$messages];
    return $new;
}

            

                final public function errorAttributes(array $attributes): static
{
    $new = clone $this;
    $new->errorAttributes = $attributes;
    $new->replaceErrorAttributes = true;
    return $new;
}

            

                final public function errorClass(?string ...$class): static
{
    $new = clone $this;
    $new->errorAttributes['class'] = $class;
    $new->replaceErrorClass = true;
    return $new;
}

            

                final public function errorConfig(array $config): static
{
    $new = clone $this;
    $new->errorConfig = $config;
    return $new;
}

            

                final public function errorId(?string $id): static
{
    $new = clone $this;
    $new->errorAttributes['id'] = $id;
    return $new;
}

            

                final public function form(?string $value): static
{
    $new = clone $this;
    $new->inputAttributes['form'] = $value;
    return $new;
}

            

                final protected function generateBeginContent(): string
{
    $parts = [
        '{input}' => $this->generateBeginInput(),
        '{label}' => ($this->hideLabel ?? $this->shouldHideLabel()) ? '' : $this->generateLabel(),
        '{hint}' => $this->generateHint(),
        '{error}' => $this->generateError(),
    ];
    return $this->makeContent($this->templateBegin, $parts);
}

            

                protected function generateBeginInput(): string
{
    return '';
}

            

                final protected function generateContent(): ?string
{
    $parts = [
        '{input}' => $this->generateInputContainerBegin()
            . $this->beforeInput
            . $this->generateInput()
            . $this->afterInput
            . $this->generateInputContainerEnd(),
        '{label}' => ($this->hideLabel ?? $this->shouldHideLabel()) ? '' : $this->generateLabel(),
        '{hint}' => $this->generateHint(),
        '{error}' => $this->generateError(),
    ];
    return $this->makeContent($this->template, $parts);
}

            

                final protected function generateEndContent(): string
{
    $parts = [
        '{input}' => $this->generateEndInput(),
        '{label}' => ($this->hideLabel ?? $this->shouldHideLabel()) ? '' : $this->generateLabel(),
        '{hint}' => $this->generateHint(),
        '{error}' => $this->generateError(),
    ];
    return $this->makeContent($this->templateEnd, $parts);
}

            

                protected function generateEndInput(): string
{
    return '';
}

            

                final protected function generateInput(): string
{
    $value = $this->getValue();
    if ($value instanceof DateTimeInterface) {
        $value = $this->formatDateTime($value);
    } elseif (!is_string($value) && $value !== null) {
        throw new InvalidArgumentException(
            (new ReflectionClass($this))->getShortName() .
            ' field requires a string or null value.'
        );
    }
    /** @psalm-suppress MixedArgument We guess that enrichment contain correct values. */
    $inputAttributes = array_merge(
        $this->enrichment['inputAttributes'] ?? [],
        $this->getInputAttributes()
    );
    return Html::input($this->getInputType(), $this->getName(), $value, $inputAttributes)->render();
}

            

                final protected function getInputAttributes(): array
{
    $attributes = $this->inputAttributes;
    $this->prepareIdInInputAttributes($attributes);
    $this->prepareInputAttributes($attributes);
    return $attributes;
}

            

                final protected function getInputData(): InputDataInterface
{
    if ($this->inputData === null) {
        $this->inputData = new InputData();
    }
    return $this->inputData;
}

            

                final protected function getName(): ?string
{
    return $this->useCustomName
        ? $this->customName
        : $this->getInputData()->getName();
}

            

                final protected static function getThemeConfig(?string $theme): array
{
    return ThemeContainer::getTheme($theme)?->getFieldConfig(static::class) ?? [];
}

            

                final protected function getValue(): mixed
{
    $value = $this->useCustomValue
        ? $this->customValue
        : $this->getInputData()->getValue();
    return $this->prepareValueCallback === null
        ? $value
        : ($this->prepareValueCallback)($value);
}

            

                final protected function hasCustomError(): bool
{
    return isset($this->errorConfig['message()']);
}

            

                final public function hideLabel(?bool $hide = true): static
{
    $new = clone $this;
    $new->hideLabel = $hide;
    return $new;
}

            

                final public function hint(?string $content): static
{
    $new = clone $this;
    $new->hintConfig['content()'] = [$content];
    return $new;
}

            

                final public function hintAttributes(array $attributes): static
{
    $new = clone $this;
    $new->hintAttributes = $attributes;
    $new->replaceHintAttributes = true;
    return $new;
}

            

                final public function hintClass(?string ...$class): static
{
    $new = clone $this;
    $new->hintAttributes['class'] = $class;
    $new->replaceHintClass = true;
    return $new;
}

            

                final public function hintConfig(array $config): static
{
    $new = clone $this;
    $new->hintConfig = $config;
    return $new;
}

            

                final public function hintId(?string $id): static
{
    $new = clone $this;
    $new->hintAttributes['id'] = $id;
    return $new;
}

            

                final public function inputAttributes(array $attributes): static
{
    $new = clone $this;
    $new->inputAttributes = $attributes;
    return $new;
}

            

                final public function inputClass(?string ...$class): static
{
    $new = clone $this;
    $new->inputAttributes['class'] = array_filter($class, static fn ($c) => $c !== null);
    return $new;
}

            

                final public function inputContainerAttributes(array $attributes): static
{
    $new = clone $this;
    $new->inputContainerAttributes = $attributes;
    return $new;
}

            

                final public function inputContainerClass(?string ...$class): static
{
    $new = clone $this;
    $new->inputContainerAttributes['class'] = array_filter($class, static fn ($c) => $c !== null);
    return $new;
}

            

                final public function inputContainerTag(?string $tag): static
{
    if ($tag === '') {
        throw new InvalidArgumentException('Tag name cannot be empty.');
    }
    $new = clone $this;
    $new->inputContainerTag = $tag;
    return $new;
}

            

                final public function inputData(InputDataInterface $inputData): static
{
    $new = clone $this;
    $new->inputData = $inputData;
    $new->useCustomName = false;
    $new->useCustomValue = false;
    return $new;
}

            

                final public function inputId(?string $inputId): static
{
    $new = clone $this;
    $new->inputId = $inputId;
    return $new;
}

            

                public function inputInvalidClass(?string $class): self
{
    $new = clone $this;
    $new->inputInvalidClass = $class;
    return $new;
}

            

                public function inputValidClass(?string $class): self
{
    $new = clone $this;
    $new->inputValidClass = $class;
    return $new;
}

            

                public function invalidClass(?string $class): self
{
    $new = clone $this;
    $new->invalidClass = $class;
    return $new;
}

            

                final public function label(?string $content): static
{
    $new = clone $this;
    $new->label = $content;
    return $new;
}

            

                final public function labelAttributes(array $attributes): static
{
    $new = clone $this;
    $new->labelAttributes = $attributes;
    $new->replaceLabelAttributes = true;
    return $new;
}

            

                final public function labelClass(?string ...$class): static
{
    $new = clone $this;
    $new->labelAttributes['class'] = $class;
    $new->replaceLabelClass = true;
    return $new;
}

            

                final public function labelConfig(array $config): static
{
    $new = clone $this;
    $new->labelConfig = $config;
    return $new;
}

            

                final public function labelId(?string $id): static
{
    $new = clone $this;
    $new->labelAttributes['id'] = $id;
    return $new;
}

            

                final public function max(?string $value): static
{
    $new = clone $this;
    $new->inputAttributes['max'] = $value;
    return $new;
}

            

                final public function min(?string $value): static
{
    $new = clone $this;
    $new->inputAttributes['min'] = $value;
    return $new;
}

            

                final public function name(?string $name): static
{
    $new = clone $this;
    $new->customName = $name;
    $new->useCustomName = true;
    return $new;
}

            

                protected function prepareContainerAttributes(array &$attributes): void
{
    $this->addValidationClassToAttributes(
        $attributes,
        $this->getInputData(),
        $this->hasCustomError() ? true : null,
    );
}

            

                final protected function prepareIdInInputAttributes(array &$attributes): void
{
    $idFromTag = $attributes['id'] ?? null;
    if ($idFromTag !== null) {
        $this->inputIdFromTag = (string) $idFromTag;
    }
    if ($this->shouldSetInputId) {
        if ($this->inputId !== null) {
            $attributes['id'] = $this->inputId;
        } elseif ($idFromTag === null) {
            $attributes['id'] = $this->getInputData()->getId();
        }
    }
}

            

                protected function prepareInputAttributes(array &$attributes): void
{
    $this->addInputValidationClassToAttributes(
        $attributes,
        $this->getInputData(),
        $this->hasCustomError() ? true : null,
    );
}

            

                final public function prepareValue(?callable $callback): static
{
    $new = clone $this;
    $new->prepareValueCallback = $callback;
    return $new;
}

            

                final public function readonly(bool $value = true): static
{
    $new = clone $this;
    $new->inputAttributes['readonly'] = $value;
    return $new;
}

            

                final public function render(): string
{
    if ($this->isStartedByBegin) {
        $this->isStartedByBegin = false;
        return $this->renderEnd();
    }
    $this->beforeRender();
    $content = $this->generateContent();
    if ($content === null) {
        $this->enrichment = [];
        return '';
    }
    $result = $this->renderOpenContainerAndContent($content);
    if ($this->useContainer) {
        $result .= "\n" . Html::closeTag($this->containerTag);
    }
    $this->enrichment = [];
    return $result;
}

            

                final protected function renderError(Error $error): string
{
    return $error
        ->inputData($this->getInputData())
        ->render();
}

            

                final protected function renderHint(Hint $hint): string
{
    return $hint
        ->inputData($this->getInputData())
        ->render();
}

            

                final protected function renderLabel(Label $label): string
{
    $label = $label->inputData($this->getInputData());
    if ($this->shouldSetInputId === false) {
        $label = $label->useInputId(false);
    }
    if ($this->inputId !== null) {
        $label = $label->forId($this->inputId);
    } elseif ($this->inputIdFromTag !== null) {
        $label = $label->forId($this->inputIdFromTag);
    }
    return $label->render();
}

            

                final public function required(bool $value = true): static
{
    $new = clone $this;
    $new->inputAttributes['required'] = $value;
    return $new;
}

            

                protected function shouldHideLabel(): bool
{
    return false;
}

            

                final public function shouldSetInputId(bool $value): static
{
    $new = clone $this;
    $new->shouldSetInputId = $value;
    return $new;
}

            

                final public function tabIndex(?int $value): static
{
    $new = clone $this;
    $new->inputAttributes['tabindex'] = $value;
    return $new;
}

            

                final public function template(string $template): static
{
    $new = clone $this;
    $new->template = $template;
    return $new;
}

            

                final public function templateBegin(string $template): static
{
    $new = clone $this;
    $new->templateBegin = $template;
    return $new;
}

            

                final public function templateEnd(string $template): static
{
    $new = clone $this;
    $new->templateEnd = $template;
    return $new;
}

            

                final public function token(string $token, string|Stringable $value): static
{
    $this->validateToken($token);
    $new = clone $this;
    $new->extraTokens[$token] = $value;
    return $new;
}

            

                final public function tokens(array $tokens): static
{
    $new = clone $this;
    foreach ($tokens as $token => $value) {
        if (!is_string($token)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Token should be string. %s given.',
                    get_debug_type($token),
                )
            );
        }
        if (!is_string($value) && !$value instanceof Stringable) {
            throw new InvalidArgumentException(
                sprintf(
                    'Token value should be string or Stringable. %s given.',
                    get_debug_type($value),
                )
            );
        }
        $this->validateToken($token);
        $new->extraTokens[$token] = $value;
    }
    return $new;
}

            

                final public function useContainer(bool $use): static
{
    $new = clone $this;
    $new->useContainer = $use;
    return $new;
}

            

                public function validClass(?string $class): self
{
    $new = clone $this;
    $new->validClass = $class;
    return $new;
}

            

                public function validationRulesEnricher(?ValidationRulesEnricherInterface $enricher): self
{
    $new = clone $this;
    $new->validationRulesEnricher = $enricher;
    return $new;
}

            

                final public function value(mixed $value): static
{
    $new = clone $this;
    $new->customValue = $value;
    $new->useCustomValue = true;
    return $new;
}