Final Class Yiisoft\Form\Field\Password

                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 beforeInput(string|Stringable $content): static
{
    $new = clone $this;
    $new->beforeInput = $content;
    return $new;
}

            

                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;
}

            

                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 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 name(?string $name): static
{
    $new = clone $this;
    $new->customName = $name;
    $new->useCustomName = true;
    return $new;
}

            

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

            

                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 preparePlaceholderInInputAttributes(array &$attributes): void
{
    if (
        $this->usePlaceholder
        && !isset($attributes['placeholder'])
    ) {
        $placeholder = $this->placeholder ?? $this->getInputData()->getPlaceholder();
        if ($placeholder !== null) {
            $attributes['placeholder'] = $placeholder;
        }
    }
}

            

                final public function prepareValue(?callable $callback): static
{
    $new = clone $this;
    $new->prepareValueCallback = $callback;
    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();
}

            

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

            

                final public function shouldSetInputId(bool $value): static
{
    $new = clone $this;
    $new->shouldSetInputId = $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 usePlaceholder(bool $use): self
{
    $new = clone $this;
    $new->usePlaceholder = $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;
}