🎨 Incluye componentes base originales de PageTop

pagetop-minimal/src/component/form_element/button.rs

@@ -0,0 +1,183 @@
+use pagetop::prelude::*;
+
+pub_handle!(COMPONENT_BUTTON);
+
+#[derive(Default)]
+pub enum ButtonType {
+    #[default]
+    Button,
+    Submit,
+    Reset,
+}
+
+#[rustfmt::skip]
+#[derive(Default)]
+pub struct Button {
+    weight     : isize,
+    renderable : Renderable,
+    classes    : Classes,
+    button_type: ButtonType,
+    name       : AttributeValue,
+    value      : AttributeValue,
+    autofocus  : AttributeValue,
+    disabled   : AttributeValue,
+    template   : String,
+}
+
+impl ComponentTrait for Button {
+    fn new() -> Self {
+        Button::default()
+            .with_classes(ClassesOp::SetDefault, "btn btn-primary")
+            .with_classes(ClassesOp::AddFirst, "form-button")
+    }
+
+    fn handle(&self) -> Handle {
+        COMPONENT_BUTTON
+    }
+
+    fn weight(&self) -> isize {
+        self.weight
+    }
+
+    fn is_renderable(&self, rcx: &RenderContext) -> bool {
+        (self.renderable.check)(rcx)
+    }
+
+    fn default_render(&self, _: &mut RenderContext) -> Markup {
+        let button_type = match self.button_type() {
+            ButtonType::Button => "button",
+            ButtonType::Submit => "submit",
+            ButtonType::Reset => "reset",
+        };
+        let id = self.name().get().map(|name| concat_string!("edit-", name));
+        html! {
+            button
+                type=(button_type)
+                id=[id]
+                class=[self.classes().get()]
+                name=[self.name().get()]
+                value=[self.value().get()]
+                autofocus=[self.autofocus().get()]
+                disabled=[self.disabled().get()]
+            {
+                @if let Some(value) = self.value().get() { (value) }
+            }
+        }
+    }
+
+    fn as_ref_any(&self) -> &dyn AnyComponent {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn AnyComponent {
+        self
+    }
+}
+
+impl Button {
+    pub fn with(value: &str) -> Self {
+        Button::new().with_value(value)
+    }
+
+    pub fn submit(value: &str) -> Self {
+        let mut button = Button::new()
+            .with_classes(ClassesOp::Replace("form-button"), "form-submit")
+            .with_value(value);
+        button.button_type = ButtonType::Submit;
+        button
+    }
+
+    pub fn reset(value: &str) -> Self {
+        let mut button = Button::new()
+            .with_classes(ClassesOp::Replace("form-button"), "form-reset")
+            .with_value(value);
+        button.button_type = ButtonType::Reset;
+        button
+    }
+
+    // Button BUILDER.
+
+    #[fn_builder]
+    pub fn alter_weight(&mut self, weight: isize) -> &mut Self {
+        self.weight = weight;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self {
+        self.renderable.check = check;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self {
+        self.classes.alter_value(op, classes);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_name(&mut self, name: &str) -> &mut Self {
+        self.name.alter_value(name);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_value(&mut self, value: &str) -> &mut Self {
+        self.value.alter_value(value);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_autofocus(&mut self, toggle: bool) -> &mut Self {
+        self.autofocus.alter_value(match toggle {
+            true => "autofocus",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_disabled(&mut self, toggle: bool) -> &mut Self {
+        self.disabled.alter_value(match toggle {
+            true => "disabled",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_template(&mut self, template: &str) -> &mut Self {
+        self.template = template.to_owned();
+        self
+    }
+
+    // Button GETTERS.
+
+    pub fn classes(&self) -> &Classes {
+        &self.classes
+    }
+
+    pub fn button_type(&self) -> &ButtonType {
+        &self.button_type
+    }
+
+    pub fn name(&self) -> &AttributeValue {
+        &self.name
+    }
+
+    pub fn value(&self) -> &AttributeValue {
+        &self.value
+    }
+
+    pub fn autofocus(&self) -> &AttributeValue {
+        &self.autofocus
+    }
+
+    pub fn disabled(&self) -> &AttributeValue {
+        &self.disabled
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}

pagetop-minimal/src/component/form_element/date.rs

@@ -0,0 +1,236 @@
+use pagetop::prelude::*;
+
+pub_handle!(COMPONENT_DATE);
+
+#[rustfmt::skip]
+#[derive(Default)]
+pub struct Date {
+    weight      : isize,
+    renderable  : Renderable,
+    classes     : Classes,
+    name        : AttributeValue,
+    value       : AttributeValue,
+    label       : AttributeValue,
+    placeholder : AttributeValue,
+    autofocus   : AttributeValue,
+    autocomplete: AttributeValue,
+    disabled    : AttributeValue,
+    readonly    : AttributeValue,
+    required    : AttributeValue,
+    help_text   : AttributeValue,
+    template    : String,
+}
+
+impl ComponentTrait for Date {
+    fn new() -> Self {
+        Date::default()
+            .with_classes(ClassesOp::SetDefault, "form-item")
+            .with_classes(ClassesOp::AddFirst, "form-type-date")
+    }
+
+    fn handle(&self) -> Handle {
+        COMPONENT_DATE
+    }
+
+    fn weight(&self) -> isize {
+        self.weight
+    }
+
+    fn is_renderable(&self, rcx: &RenderContext) -> bool {
+        (self.renderable.check)(rcx)
+    }
+
+    fn default_render(&self, _: &mut RenderContext) -> Markup {
+        let id = self.name().get().map(|name| concat_string!("edit-", name));
+        html! {
+            div class=[self.classes().get()] {
+                @if let Some(label) = self.label().get() {
+                    label class="form-label" for=[&id] {
+                        (label) " "
+                        @if self.required().get().is_some() {
+                            span
+                                class="form-required"
+                                title="Este campo es obligatorio." { "*" } " ";
+                        }
+                    }
+                }
+                input
+                    type="date"
+                    id=[id]
+                    class="form-control"
+                    name=[self.name().get()]
+                    value=[self.value().get()]
+                    placeholder=[self.placeholder().get()]
+                    autofocus=[self.autofocus().get()]
+                    autocomplete=[self.autocomplete().get()]
+                    readonly=[self.readonly().get()]
+                    required=[self.required().get()]
+                    disabled=[self.disabled().get()];
+                @if let Some(help_text) = self.help_text().get() {
+                    div class="form-text" { (help_text) }
+                }
+            }
+        }
+    }
+
+    fn as_ref_any(&self) -> &dyn AnyComponent {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn AnyComponent {
+        self
+    }
+}
+
+impl Date {
+    // Date BUILDER.
+
+    #[fn_builder]
+    pub fn alter_weight(&mut self, weight: isize) -> &mut Self {
+        self.weight = weight;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self {
+        self.renderable.check = check;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self {
+        self.classes.alter_value(op, classes);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_name(&mut self, name: &str) -> &mut Self {
+        self.name.alter_value(name);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_value(&mut self, value: &str) -> &mut Self {
+        self.value.alter_value(value);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_label(&mut self, label: &str) -> &mut Self {
+        self.label.alter_value(label);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_placeholder(&mut self, placeholder: &str) -> &mut Self {
+        self.placeholder.alter_value(placeholder);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_autofocus(&mut self, toggle: bool) -> &mut Self {
+        self.autofocus.alter_value(match toggle {
+            true => "autofocus",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_autocomplete(&mut self, toggle: bool) -> &mut Self {
+        self.autocomplete.alter_value(match toggle {
+            true => "",
+            false => "off",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_disabled(&mut self, toggle: bool) -> &mut Self {
+        self.disabled.alter_value(match toggle {
+            true => "disabled",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_readonly(&mut self, toggle: bool) -> &mut Self {
+        self.readonly.alter_value(match toggle {
+            true => "readonly",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_required(&mut self, toggle: bool) -> &mut Self {
+        self.required.alter_value(match toggle {
+            true => "required",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_help_text(&mut self, help_text: &str) -> &mut Self {
+        self.help_text.alter_value(help_text);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_template(&mut self, template: &str) -> &mut Self {
+        self.template = template.to_owned();
+        self
+    }
+
+    // Date GETTERS.
+
+    pub fn classes(&self) -> &Classes {
+        &self.classes
+    }
+
+    pub fn name(&self) -> &AttributeValue {
+        &self.name
+    }
+
+    pub fn value(&self) -> &AttributeValue {
+        &self.value
+    }
+
+    pub fn label(&self) -> &AttributeValue {
+        &self.label
+    }
+
+    pub fn placeholder(&self) -> &AttributeValue {
+        &self.placeholder
+    }
+
+    pub fn autofocus(&self) -> &AttributeValue {
+        &self.autofocus
+    }
+
+    pub fn autocomplete(&self) -> &AttributeValue {
+        &self.autocomplete
+    }
+
+    pub fn disabled(&self) -> &AttributeValue {
+        &self.disabled
+    }
+
+    pub fn readonly(&self) -> &AttributeValue {
+        &self.readonly
+    }
+
+    pub fn required(&self) -> &AttributeValue {
+        &self.required
+    }
+
+    pub fn help_text(&self) -> &AttributeValue {
+        &self.help_text
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}

pagetop-minimal/src/component/form_element/form.rs

@@ -0,0 +1,164 @@
+use pagetop::prelude::*;
+
+pub_handle!(COMPONENT_FORM);
+
+hook_before_render_component!(HOOK_BEFORE_RENDER_FORM, Form);
+
+#[derive(Default)]
+pub enum FormMethod {
+    #[default]
+    Post,
+    Get,
+}
+
+#[rustfmt::skip]
+#[derive(Default)]
+pub struct Form {
+    weight    : isize,
+    renderable: Renderable,
+    id        : IdentifierValue,
+    classes   : Classes,
+    action    : AttributeValue,
+    charset   : AttributeValue,
+    method    : FormMethod,
+    elements  : ComponentsBundle,
+    template  : String,
+}
+
+impl ComponentTrait for Form {
+    fn new() -> Self {
+        Form::default()
+            .with_classes(ClassesOp::SetDefault, "form")
+            .with_charset("UTF-8")
+    }
+
+    fn handle(&self) -> Handle {
+        COMPONENT_FORM
+    }
+
+    fn weight(&self) -> isize {
+        self.weight
+    }
+
+    fn is_renderable(&self, rcx: &RenderContext) -> bool {
+        (self.renderable.check)(rcx)
+    }
+
+    fn before_render(&mut self, rcx: &mut RenderContext) {
+        before_render_inline(self, rcx);
+    }
+
+    fn default_render(&self, rcx: &mut RenderContext) -> Markup {
+        let method = match self.method() {
+            FormMethod::Post => Some("post".to_owned()),
+            FormMethod::Get => None,
+        };
+        html! {
+            form
+                id=[self.id().get()]
+                class=[self.classes().get()]
+                action=[self.action().get()]
+                method=[method]
+                accept-charset=[self.charset().get()]
+            {
+                div { (self.elements().render(rcx)) }
+            }
+        }
+    }
+
+    fn as_ref_any(&self) -> &dyn AnyComponent {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn AnyComponent {
+        self
+    }
+}
+
+impl Form {
+    // Form BUILDER.
+
+    #[fn_builder]
+    pub fn alter_weight(&mut self, weight: isize) -> &mut Self {
+        self.weight = weight;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self {
+        self.renderable.check = check;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_id(&mut self, id: &str) -> &mut Self {
+        self.id.alter_value(id);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self {
+        self.classes.alter_value(op, classes);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_action(&mut self, action: &str) -> &mut Self {
+        self.action.alter_value(action);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_charset(&mut self, charset: &str) -> &mut Self {
+        self.charset.alter_value(charset);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_method(&mut self, method: FormMethod) -> &mut Self {
+        self.method = method;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_element(&mut self, element: impl ComponentTrait) -> &mut Self {
+        self.elements.add(element);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_template(&mut self, template: &str) -> &mut Self {
+        self.template = template.to_owned();
+        self
+    }
+
+    // Form GETTERS.
+
+    pub fn id(&self) -> &IdentifierValue {
+        &self.id
+    }
+
+    pub fn classes(&self) -> &Classes {
+        &self.classes
+    }
+
+    pub fn action(&self) -> &AttributeValue {
+        &self.action
+    }
+
+    pub fn charset(&self) -> &AttributeValue {
+        &self.charset
+    }
+
+    pub fn method(&self) -> &FormMethod {
+        &self.method
+    }
+
+    pub fn elements(&self) -> &ComponentsBundle {
+        &self.elements
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}

pagetop-minimal/src/component/form_element/hidden.rs

@@ -0,0 +1,76 @@
+use pagetop::prelude::*;
+
+pub_handle!(COMPONENT_HIDDEN);
+
+#[rustfmt::skip]
+#[derive(Default)]
+pub struct Hidden {
+    weight: isize,
+    name  : NameValue,
+    value : AttributeValue,
+}
+
+impl ComponentTrait for Hidden {
+    fn new() -> Self {
+        Hidden::default()
+    }
+
+    fn handle(&self) -> Handle {
+        COMPONENT_HIDDEN
+    }
+
+    fn weight(&self) -> isize {
+        self.weight
+    }
+
+    fn default_render(&self, _: &mut RenderContext) -> Markup {
+        let id = self.name().get().map(|name| concat_string!("value-", name));
+        html! {
+            input type="hidden" id=[id] name=[self.name().get()] value=[self.value().get()];
+        }
+    }
+
+    fn as_ref_any(&self) -> &dyn AnyComponent {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn AnyComponent {
+        self
+    }
+}
+
+impl Hidden {
+    pub fn set(name: &str, value: &str) -> Self {
+        Hidden::new().with_name(name).with_value(value)
+    }
+
+    // Hidden BUILDER.
+
+    #[fn_builder]
+    pub fn alter_weight(&mut self, weight: isize) -> &mut Self {
+        self.weight = weight;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_name(&mut self, name: &str) -> &mut Self {
+        self.name.alter_value(name);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_value(&mut self, value: &str) -> &mut Self {
+        self.value.alter_value(value);
+        self
+    }
+
+    // Hidden GETTERS.
+
+    pub fn name(&self) -> &NameValue {
+        &self.name
+    }
+
+    pub fn value(&self) -> &AttributeValue {
+        &self.value
+    }
+}

pagetop-minimal/src/component/form_element/input.rs

@@ -0,0 +1,357 @@
+use pagetop::prelude::*;
+
+pub_handle!(COMPONENT_INPUT);
+
+#[derive(Default)]
+pub enum InputType {
+    #[default]
+    Textfield,
+    Password,
+    Search,
+    Email,
+    Telephone,
+    Url,
+}
+
+#[rustfmt::skip]
+#[derive(Default)]
+pub struct Input {
+    weight      : isize,
+    renderable  : Renderable,
+    classes     : Classes,
+    input_type  : InputType,
+    name        : NameValue,
+    value       : AttributeValue,
+    label       : AttributeValue,
+    size        : Option<u16>,
+    minlength   : Option<u16>,
+    maxlength   : Option<u16>,
+    placeholder : AttributeValue,
+    autofocus   : AttributeValue,
+    autocomplete: AttributeValue,
+    disabled    : AttributeValue,
+    readonly    : AttributeValue,
+    required    : AttributeValue,
+    help_text   : AttributeValue,
+    template    : String,
+}
+
+impl ComponentTrait for Input {
+    fn new() -> Self {
+        Input::default()
+            .with_classes(ClassesOp::SetDefault, "form-item")
+            .with_classes(ClassesOp::AddFirst, "form-type-textfield")
+            .with_size(Some(60))
+            .with_maxlength(Some(128))
+    }
+
+    fn handle(&self) -> Handle {
+        COMPONENT_INPUT
+    }
+
+    fn weight(&self) -> isize {
+        self.weight
+    }
+
+    fn is_renderable(&self, rcx: &RenderContext) -> bool {
+        (self.renderable.check)(rcx)
+    }
+
+    #[rustfmt::skip]
+    fn default_render(&self, _: &mut RenderContext) -> Markup {
+        let type_input = match self.input_type() {
+            InputType::Textfield => "text",
+            InputType::Password  => "password",
+            InputType::Search    => "search",
+            InputType::Email     => "email",
+            InputType::Telephone => "tel",
+            InputType::Url       => "url",
+        };
+        let id = self.name().get().map(|name| concat_string!("edit-", name));
+        html! {
+            div class=[self.classes().get()] {
+                @if let Some(label) = self.label().get() {
+                    label class="form-label" for=[&id] {
+                        (label) " "
+                        @if self.required().get().is_some() {
+                            span
+                                class="form-required"
+                                title="Este campo es obligatorio." { "*" } " ";
+                        }
+                    }
+                }
+                input
+                    type=(type_input)
+                    id=[id]
+                    class="form-control"
+                    name=[self.name().get()]
+                    value=[self.value().get()]
+                    size=[self.size()]
+                    minlength=[self.minlength()]
+                    maxlength=[self.maxlength()]
+                    placeholder=[self.placeholder().get()]
+                    autofocus=[self.autofocus().get()]
+                    autocomplete=[self.autocomplete().get()]
+                    readonly=[self.readonly().get()]
+                    required=[self.required().get()]
+                    disabled=[self.disabled().get()];
+                @if let Some(help_text) = self.help_text().get() {
+                    div class="form-text" { (help_text) }
+                }
+            }
+        }
+    }
+
+    fn as_ref_any(&self) -> &dyn AnyComponent {
+        self
+    }
+
+    fn as_mut_any(&mut self) -> &mut dyn AnyComponent {
+        self
+    }
+}
+
+impl Input {
+    pub fn textfield() -> Self {
+        Input::new()
+    }
+
+    #[rustfmt::skip]
+    pub fn password() -> Self {
+        let mut input = Input::new().with_classes(
+            ClassesOp::Replace("form-type-textfield"),
+            "form-type-password",
+        );
+        input.input_type = InputType::Password;
+        input
+    }
+
+    #[rustfmt::skip]
+    pub fn search() -> Self {
+        let mut input = Input::new().with_classes(
+            ClassesOp::Replace("form-type-textfield"),
+            "form-type-search",
+        );
+        input.input_type = InputType::Search;
+        input
+    }
+
+    #[rustfmt::skip]
+    pub fn email() -> Self {
+        let mut input = Input::new().with_classes(
+            ClassesOp::Replace("form-type-textfield"),
+            "form-type-email"
+        );
+        input.input_type = InputType::Email;
+        input
+    }
+
+    #[rustfmt::skip]
+    pub fn telephone() -> Self {
+        let mut input = Input::new().with_classes(
+            ClassesOp::Replace("form-type-textfield"),
+            "form-type-telephone",
+        );
+        input.input_type = InputType::Telephone;
+        input
+    }
+
+    #[rustfmt::skip]
+    pub fn url() -> Self {
+        let mut input = Input::new().with_classes(
+            ClassesOp::Replace("form-type-textfield"),
+            "form-type-url"
+        );
+        input.input_type = InputType::Url;
+        input
+    }
+
+    // Input BUILDER.
+
+    #[fn_builder]
+    pub fn alter_weight(&mut self, weight: isize) -> &mut Self {
+        self.weight = weight;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self {
+        self.renderable.check = check;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self {
+        self.classes.alter_value(op, classes);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_name(&mut self, name: &str) -> &mut Self {
+        self.name.alter_value(name);
+        self.alter_classes(
+            ClassesOp::SetDefault,
+            concat_string!("form-item form-item-", name).as_str(),
+        );
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_value(&mut self, value: &str) -> &mut Self {
+        self.value.alter_value(value);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_label(&mut self, label: &str) -> &mut Self {
+        self.label.alter_value(label);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_size(&mut self, size: Option<u16>) -> &mut Self {
+        self.size = size;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_minlength(&mut self, minlength: Option<u16>) -> &mut Self {
+        self.minlength = minlength;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_maxlength(&mut self, maxlength: Option<u16>) -> &mut Self {
+        self.maxlength = maxlength;
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_placeholder(&mut self, placeholder: &str) -> &mut Self {
+        self.placeholder.alter_value(placeholder);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_autofocus(&mut self, toggle: bool) -> &mut Self {
+        self.autofocus.alter_value(match toggle {
+            true => "autofocus",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_autocomplete(&mut self, toggle: bool) -> &mut Self {
+        self.autocomplete.alter_value(match toggle {
+            true => "",
+            false => "off",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_disabled(&mut self, toggle: bool) -> &mut Self {
+        self.disabled.alter_value(match toggle {
+            true => "disabled",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_readonly(&mut self, toggle: bool) -> &mut Self {
+        self.readonly.alter_value(match toggle {
+            true => "readonly",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_required(&mut self, toggle: bool) -> &mut Self {
+        self.required.alter_value(match toggle {
+            true => "required",
+            false => "",
+        });
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_help_text(&mut self, help_text: &str) -> &mut Self {
+        self.help_text.alter_value(help_text);
+        self
+    }
+
+    #[fn_builder]
+    pub fn alter_template(&mut self, template: &str) -> &mut Self {
+        self.template = template.to_owned();
+        self
+    }
+
+    // Input GETTERS.
+
+    pub fn classes(&self) -> &Classes {
+        &self.classes
+    }
+
+    pub fn input_type(&self) -> &InputType {
+        &self.input_type
+    }
+
+    pub fn name(&self) -> &NameValue {
+        &self.name
+    }
+
+    pub fn value(&self) -> &AttributeValue {
+        &self.value
+    }
+
+    pub fn label(&self) -> &AttributeValue {
+        &self.label
+    }
+
+    pub fn size(&self) -> Option<u16> {
+        self.size
+    }
+
+    pub fn minlength(&self) -> Option<u16> {
+        self.minlength
+    }
+
+    pub fn maxlength(&self) -> Option<u16> {
+        self.maxlength
+    }
+
+    pub fn placeholder(&self) -> &AttributeValue {
+        &self.placeholder
+    }
+
+    pub fn autofocus(&self) -> &AttributeValue {
+        &self.autofocus
+    }
+
+    pub fn autocomplete(&self) -> &AttributeValue {
+        &self.autocomplete
+    }
+
+    pub fn disabled(&self) -> &AttributeValue {
+        &self.disabled
+    }
+
+    pub fn readonly(&self) -> &AttributeValue {
+        &self.readonly
+    }
+
+    pub fn required(&self) -> &AttributeValue {
+        &self.required
+    }
+
+    pub fn help_text(&self) -> &AttributeValue {
+        &self.help_text
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}