valtech-components 4.0.73 → 4.0.76

package/esm2022/lib/components/molecules/request-form/request-form.component.mjs

@@ -0,0 +1,229 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Input, Output, inject, signal } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { IonButton, IonIcon } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { checkmarkCircleOutline, closeCircleOutline } from 'ionicons/icons';
+import { firstValueFrom } from 'rxjs';
+import { RequestService } from '../../../services/requests/request.service';
+import { FeedbackService } from '../../../services/feedback/feedback.service';
+import { I18nService } from '../../../services/i18n';
+import { ComponentStates, InputType } from '../../types';
+import { FormComponent } from '../../organisms/form/form.component';
+import { AttachmentUploaderComponent } from '../../organisms/attachment-uploader/attachment-uploader.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const REQUEST_FORM_I18N = {
+    es: {
+        title: 'Título',
+        titlePlaceholder: 'Describe brevemente tu solicitud',
+        titleValidation: 'El título debe tener al menos 3 caracteres',
+        description: 'Descripción',
+        descriptionPlaceholder: 'Añade más detalles aquí',
+        descriptionValidation: 'La descripción es demasiado larga',
+        submit: 'Enviar',
+        success: 'Solicitud enviada exitosamente',
+        error: 'Error al enviar la solicitud',
+    },
+    en: {
+        title: 'Title',
+        titlePlaceholder: 'Briefly describe your request',
+        titleValidation: 'Title must be at least 3 characters',
+        description: 'Description',
+        descriptionPlaceholder: 'Add more details here',
+        descriptionValidation: 'Description is too long',
+        submit: 'Submit',
+        success: 'Request submitted successfully',
+        error: 'Error submitting the request',
+    },
+};
+export class RequestFormComponent {
+    constructor() {
+        this.props = { type: '' };
+        this.onSubmit = new EventEmitter();
+        this.onCancel = new EventEmitter();
+        this.i18n = inject(I18nService);
+        this.requestService = inject(RequestService);
+        this.feedbackService = inject(FeedbackService);
+        this.isSubmitting = signal(false);
+        this.isSuccess = signal(false);
+        this.error = signal(null);
+        this.currentAttachments = [];
+        addIcons({ checkmarkCircleOutline, closeCircleOutline });
+        if (!this.i18n.hasNamespace('RequestForm')) {
+            this.i18n.registerDefaults('RequestForm', REQUEST_FORM_I18N);
+        }
+    }
+    ngOnInit() {
+        this.formProps = this.buildFormProps();
+    }
+    buildFormProps() {
+        return {
+            name: '',
+            sections: [
+                {
+                    name: '',
+                    order: 0,
+                    fields: [
+                        {
+                            token: 'request-title',
+                            name: 'title',
+                            label: this.props.titleLabel ?? this.t('title'),
+                            hint: '',
+                            placeholder: this.props.titlePlaceholder ?? this.t('titlePlaceholder'),
+                            type: InputType.TEXT,
+                            order: 1,
+                            validators: [Validators.required, Validators.minLength(3), Validators.maxLength(300)],
+                            errors: {
+                                required: this.t('titleValidation'),
+                                minlength: this.t('titleValidation'),
+                                maxlength: this.t('titleValidation'),
+                            },
+                            state: ComponentStates.ENABLED,
+                        },
+                        {
+                            token: 'request-description',
+                            name: 'description',
+                            label: this.props.descriptionLabel ?? this.t('description'),
+                            hint: '',
+                            placeholder: this.props.descriptionPlaceholder ?? this.t('descriptionPlaceholder'),
+                            type: InputType.TEXTAREA,
+                            order: 2,
+                            validators: [Validators.maxLength(5000)],
+                            errors: { maxlength: this.t('descriptionValidation') },
+                            state: ComponentStates.ENABLED,
+                        },
+                    ],
+                },
+            ],
+            actions: {
+                type: 'submit',
+                color: 'dark',
+                fill: 'solid',
+                shape: 'round',
+                expand: 'block',
+                text: this.props.submitButtonText ?? this.t('submit'),
+                state: ComponentStates.ENABLED,
+            },
+            state: ComponentStates.ENABLED,
+        };
+    }
+    async handleFormSubmit(submitted) {
+        if (this.isSubmitting())
+            return;
+        if (this.currentAttachments.some(a => a.status === 'uploading'))
+            return;
+        this.isSubmitting.set(true);
+        this.error.set(null);
+        this.isSuccess.set(false);
+        this.formProps.state = ComponentStates.WORKING;
+        this.formProps.actions.state = ComponentStates.WORKING;
+        try {
+            const title = submitted.fields['title'].trim();
+            const description = submitted.fields['description']?.trim() ?? '';
+            const attachmentUrls = this.currentAttachments.filter(a => a.status === 'ready').map(a => a.url);
+            const result = await firstValueFrom(this.requestService.createRequest({
+                type: this.props.type,
+                title,
+                fields: {
+                    ...(description ? { description } : {}),
+                    ...(attachmentUrls.length ? { attachmentUrls } : {}),
+                },
+            }));
+            this.isSuccess.set(true);
+            this.onSubmit.emit({
+                requestId: result.requestId,
+                request: result.request,
+                type: this.props.type,
+                title,
+                attachmentUrls,
+            });
+        }
+        catch (err) {
+            this.error.set(err.error?.message || err.message || this.t('error'));
+        }
+        finally {
+            this.isSubmitting.set(false);
+            this.formProps.state = ComponentStates.ENABLED;
+            this.formProps.actions.state = ComponentStates.ENABLED;
+        }
+    }
+    onAttachmentsChange(items) {
+        this.currentAttachments = items;
+    }
+    onCancelClick() {
+        this.onCancel.emit();
+    }
+    t(key) {
+        return this.i18n.t(key, 'RequestForm');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RequestFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: RequestFormComponent, isStandalone: true, selector: "val-request-form", inputs: { props: "props" }, outputs: { onSubmit: "onSubmit", onCancel: "onCancel" }, ngImport: i0, template: `
+    <div class="request-form-wrapper" [class.compact]="props.compact" [ngClass]="props.cssClass">
+      <val-form [props]="formProps" (onSubmit)="handleFormSubmit($event)">
+        @if (props.showAttachments !== false) {
+          <val-attachment-uploader [props]="{ maxFiles: 5 }" (attachmentsChange)="onAttachmentsChange($event)" />
+        }
+
+        @if (error()) {
+          <div class="request-alert error">
+            <ion-icon name="close-circle-outline" aria-hidden="true" />
+            <span>{{ error() }}</span>
+          </div>
+        }
+
+        @if (isSuccess()) {
+          <div class="request-alert success">
+            <ion-icon name="checkmark-circle-outline" aria-hidden="true" />
+            <span>{{ props.successMessage || t('success') }}</span>
+          </div>
+        }
+      </val-form>
+
+      @if (props.cancelButtonText) {
+        <ion-button fill="outline" color="medium" expand="block" class="cancel-button" (click)="onCancelClick()">
+          {{ props.cancelButtonText }}
+        </ion-button>
+      }
+    </div>
+  `, isInline: true, styles: [".request-form-wrapper{display:flex;flex-direction:column;gap:8px;&.compact{gap:4px}}.request-alert{display:flex;align-items:center;gap:8px;padding:12px 16px;border-radius:8px;margin-top:8px;&.error{background-color:var(--ion-color-danger-tint);color:var(--ion-color-danger-shade)}&.success{background-color:var(--ion-color-success-tint);color:var(--ion-color-success-shade)}ion-icon{font-size:1.25rem}}.cancel-button{margin-top:8px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: FormComponent, selector: "val-form", inputs: ["props"], outputs: ["onSubmit", "onInvalid", "onSelectChange"] }, { kind: "component", type: AttachmentUploaderComponent, selector: "val-attachment-uploader", inputs: ["props"], outputs: ["attachmentsChange"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RequestFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-request-form', standalone: true, imports: [CommonModule, FormComponent, AttachmentUploaderComponent, IonButton, IonIcon], template: `
+    <div class="request-form-wrapper" [class.compact]="props.compact" [ngClass]="props.cssClass">
+      <val-form [props]="formProps" (onSubmit)="handleFormSubmit($event)">
+        @if (props.showAttachments !== false) {
+          <val-attachment-uploader [props]="{ maxFiles: 5 }" (attachmentsChange)="onAttachmentsChange($event)" />
+        }
+
+        @if (error()) {
+          <div class="request-alert error">
+            <ion-icon name="close-circle-outline" aria-hidden="true" />
+            <span>{{ error() }}</span>
+          </div>
+        }
+
+        @if (isSuccess()) {
+          <div class="request-alert success">
+            <ion-icon name="checkmark-circle-outline" aria-hidden="true" />
+            <span>{{ props.successMessage || t('success') }}</span>
+          </div>
+        }
+      </val-form>
+
+      @if (props.cancelButtonText) {
+        <ion-button fill="outline" color="medium" expand="block" class="cancel-button" (click)="onCancelClick()">
+          {{ props.cancelButtonText }}
+        </ion-button>
+      }
+    </div>
+  `, styles: [".request-form-wrapper{display:flex;flex-direction:column;gap:8px;&.compact{gap:4px}}.request-alert{display:flex;align-items:center;gap:8px;padding:12px 16px;border-radius:8px;margin-top:8px;&.error{background-color:var(--ion-color-danger-tint);color:var(--ion-color-danger-shade)}&.success{background-color:var(--ion-color-success-tint);color:var(--ion-color-success-shade)}ion-icon{font-size:1.25rem}}.cancel-button{margin-top:8px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { props: [{
+                type: Input
+            }], onSubmit: [{
+                type: Output
+            }], onCancel: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request-form.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/molecules/request-form/request-form.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, Input, OnInit, Output, inject, signal } from '@angular/core';\nimport { Validators } from '@angular/forms';\nimport { IonButton, IonIcon } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { checkmarkCircleOutline, closeCircleOutline } from 'ionicons/icons';\nimport { firstValueFrom } from 'rxjs';\n\nimport { RequestService } from '../../../services/requests/request.service';\nimport { FeedbackService } from '../../../services/feedback/feedback.service';\nimport { I18nService } from '../../../services/i18n';\nimport { ComponentStates, FormMetadata, FormSubmit, InputMetadata, InputType } from '../../types';\nimport { FormComponent } from '../../organisms/form/form.component';\nimport { AttachmentUploaderComponent } from '../../organisms/attachment-uploader/attachment-uploader.component';\nimport { AttachmentItem } from '../../organisms/attachment-uploader/types';\nimport { RequestFormMetadata, RequestSubmitEvent } from './types';\n\nconst REQUEST_FORM_I18N = {\n  es: {\n    title: 'Título',\n    titlePlaceholder: 'Describe brevemente tu solicitud',\n    titleValidation: 'El título debe tener al menos 3 caracteres',\n    description: 'Descripción',\n    descriptionPlaceholder: 'Añade más detalles aquí',\n    descriptionValidation: 'La descripción es demasiado larga',\n    submit: 'Enviar',\n    success: 'Solicitud enviada exitosamente',\n    error: 'Error al enviar la solicitud',\n  },\n  en: {\n    title: 'Title',\n    titlePlaceholder: 'Briefly describe your request',\n    titleValidation: 'Title must be at least 3 characters',\n    description: 'Description',\n    descriptionPlaceholder: 'Add more details here',\n    descriptionValidation: 'Description is too long',\n    submit: 'Submit',\n    success: 'Request submitted successfully',\n    error: 'Error submitting the request',\n  },\n};\n\n@Component({\n  selector: 'val-request-form',\n  standalone: true,\n  imports: [CommonModule, FormComponent, AttachmentUploaderComponent, IonButton, IonIcon],\n  template: `\n    <div class=\"request-form-wrapper\" [class.compact]=\"props.compact\" [ngClass]=\"props.cssClass\">\n      <val-form [props]=\"formProps\" (onSubmit)=\"handleFormSubmit($event)\">\n        @if (props.showAttachments !== false) {\n          <val-attachment-uploader [props]=\"{ maxFiles: 5 }\" (attachmentsChange)=\"onAttachmentsChange($event)\" />\n        }\n\n        @if (error()) {\n          <div class=\"request-alert error\">\n            <ion-icon name=\"close-circle-outline\" aria-hidden=\"true\" />\n            <span>{{ error() }}</span>\n          </div>\n        }\n\n        @if (isSuccess()) {\n          <div class=\"request-alert success\">\n            <ion-icon name=\"checkmark-circle-outline\" aria-hidden=\"true\" />\n            <span>{{ props.successMessage || t('success') }}</span>\n          </div>\n        }\n      </val-form>\n\n      @if (props.cancelButtonText) {\n        <ion-button fill=\"outline\" color=\"medium\" expand=\"block\" class=\"cancel-button\" (click)=\"onCancelClick()\">\n          {{ props.cancelButtonText }}\n        </ion-button>\n      }\n    </div>\n  `,\n  styles: [\n    `\n      .request-form-wrapper {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n\n        &.compact {\n          gap: 4px;\n        }\n      }\n\n      .request-alert {\n        display: flex;\n        align-items: center;\n        gap: 8px;\n        padding: 12px 16px;\n        border-radius: 8px;\n        margin-top: 8px;\n\n        &.error {\n          background-color: var(--ion-color-danger-tint);\n          color: var(--ion-color-danger-shade);\n        }\n\n        &.success {\n          background-color: var(--ion-color-success-tint);\n          color: var(--ion-color-success-shade);\n        }\n\n        ion-icon {\n          font-size: 1.25rem;\n        }\n      }\n\n      .cancel-button {\n        margin-top: 8px;\n      }\n    `,\n  ],\n})\nexport class RequestFormComponent implements OnInit {\n  @Input() props: RequestFormMetadata = { type: '' };\n\n  @Output() onSubmit = new EventEmitter<RequestSubmitEvent>();\n  @Output() onCancel = new EventEmitter<void>();\n\n  protected i18n = inject(I18nService);\n  private requestService = inject(RequestService);\n  private feedbackService = inject(FeedbackService);\n\n  formProps!: FormMetadata;\n\n  isSubmitting = signal(false);\n  isSuccess = signal(false);\n  error = signal<string | null>(null);\n\n  private currentAttachments: AttachmentItem[] = [];\n\n  constructor() {\n    addIcons({ checkmarkCircleOutline, closeCircleOutline });\n    if (!this.i18n.hasNamespace('RequestForm')) {\n      this.i18n.registerDefaults('RequestForm', REQUEST_FORM_I18N);\n    }\n  }\n\n  ngOnInit(): void {\n    this.formProps = this.buildFormProps();\n  }\n\n  private buildFormProps(): FormMetadata {\n    return {\n      name: '',\n      sections: [\n        {\n          name: '',\n          order: 0,\n          fields: [\n            {\n              token: 'request-title',\n              name: 'title',\n              label: this.props.titleLabel ?? this.t('title'),\n              hint: '',\n              placeholder: this.props.titlePlaceholder ?? this.t('titlePlaceholder'),\n              type: InputType.TEXT,\n              order: 1,\n              validators: [Validators.required, Validators.minLength(3), Validators.maxLength(300)],\n              errors: {\n                required: this.t('titleValidation'),\n                minlength: this.t('titleValidation'),\n                maxlength: this.t('titleValidation'),\n              },\n              state: ComponentStates.ENABLED,\n            } as InputMetadata,\n            {\n              token: 'request-description',\n              name: 'description',\n              label: this.props.descriptionLabel ?? this.t('description'),\n              hint: '',\n              placeholder: this.props.descriptionPlaceholder ?? this.t('descriptionPlaceholder'),\n              type: InputType.TEXTAREA,\n              order: 2,\n              validators: [Validators.maxLength(5000)],\n              errors: { maxlength: this.t('descriptionValidation') },\n              state: ComponentStates.ENABLED,\n            } as InputMetadata,\n          ],\n        },\n      ],\n      actions: {\n        type: 'submit',\n        color: 'dark',\n        fill: 'solid',\n        shape: 'round',\n        expand: 'block',\n        text: this.props.submitButtonText ?? this.t('submit'),\n        state: ComponentStates.ENABLED,\n      },\n      state: ComponentStates.ENABLED,\n    };\n  }\n\n  async handleFormSubmit(submitted: FormSubmit): Promise<void> {\n    if (this.isSubmitting()) return;\n    if (this.currentAttachments.some(a => a.status === 'uploading')) return;\n\n    this.isSubmitting.set(true);\n    this.error.set(null);\n    this.isSuccess.set(false);\n    this.formProps.state = ComponentStates.WORKING;\n    this.formProps.actions.state = ComponentStates.WORKING;\n\n    try {\n      const title = (submitted.fields['title'] as string).trim();\n      const description = (submitted.fields['description'] as string)?.trim() ?? '';\n      const attachmentUrls = this.currentAttachments.filter(a => a.status === 'ready').map(a => a.url!);\n\n      const result = await firstValueFrom(\n        this.requestService.createRequest({\n          type: this.props.type,\n          title,\n          fields: {\n            ...(description ? { description } : {}),\n            ...(attachmentUrls.length ? { attachmentUrls } : {}),\n          },\n        })\n      );\n\n      this.isSuccess.set(true);\n      this.onSubmit.emit({\n        requestId: result.requestId,\n        request: result.request,\n        type: this.props.type,\n        title,\n        attachmentUrls,\n      });\n    } catch (err: any) {\n      this.error.set(err.error?.message || err.message || this.t('error'));\n    } finally {\n      this.isSubmitting.set(false);\n      this.formProps.state = ComponentStates.ENABLED;\n      this.formProps.actions.state = ComponentStates.ENABLED;\n    }\n  }\n\n  onAttachmentsChange(items: AttachmentItem[]): void {\n    this.currentAttachments = items;\n  }\n\n  onCancelClick(): void {\n    this.onCancel.emit();\n  }\n\n  protected t(key: string): string {\n    return this.i18n.t(key, 'RequestForm');\n  }\n}\n"]}

package/esm2022/lib/components/molecules/request-form/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvbW9sZWN1bGVzL3JlcXVlc3QtZm9ybS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXBwUmVxdWVzdCB9IGZyb20gJy4uLy4uLy4uL3NlcnZpY2VzL3JlcXVlc3RzL3R5cGVzJztcblxuZXhwb3J0IGludGVyZmFjZSBSZXF1ZXN0Rm9ybU1ldGFkYXRhIHtcbiAgLyoqIFJlcXVlc3QgdHlwZSBpZGVudGlmaWVyIChlLmcuICdzdXBwb3J0X3RpY2tldCcsICdmZWF0dXJlX3JlcXVlc3QnKS4gUmVxdWlyZWQuICovXG4gIHR5cGU6IHN0cmluZztcblxuICAvKiogTGFiZWwgZm9yIHRoZSB0aXRsZSBmaWVsZCAqL1xuICB0aXRsZUxhYmVsPzogc3RyaW5nO1xuXG4gIC8qKiBQbGFjZWhvbGRlciBmb3IgdGhlIHRpdGxlIGZpZWxkICovXG4gIHRpdGxlUGxhY2Vob2xkZXI/OiBzdHJpbmc7XG5cbiAgLyoqIExhYmVsIGZvciB0aGUgZGVzY3JpcHRpb24gZmllbGQgKi9cbiAgZGVzY3JpcHRpb25MYWJlbD86IHN0cmluZztcblxuICAvKiogUGxhY2Vob2xkZXIgZm9yIHRoZSBkZXNjcmlwdGlvbiBmaWVsZCAqL1xuICBkZXNjcmlwdGlvblBsYWNlaG9sZGVyPzogc3RyaW5nO1xuXG4gIC8qKiBTdWJtaXQgYnV0dG9uIHRleHQgKi9cbiAgc3VibWl0QnV0dG9uVGV4dD86IHN0cmluZztcblxuICAvKiogQ2FuY2VsIGJ1dHRvbiB0ZXh0IOKAlCBpZiBvbWl0dGVkLCBubyBjYW5jZWwgYnV0dG9uIGlzIHNob3duICovXG4gIGNhbmNlbEJ1dHRvblRleHQ/OiBzdHJpbmc7XG5cbiAgLyoqIFNob3cgYXR0YWNobWVudCB1cGxvYWRlciAoZGVmYXVsdDogdHJ1ZSkgKi9cbiAgc2hvd0F0dGFjaG1lbnRzPzogYm9vbGVhbjtcblxuICAvKiogQ3VzdG9tIHN1Y2Nlc3MgbWVzc2FnZSDigJQgb3ZlcnJpZGVzIGkxOG4gZGVmYXVsdCAqL1xuICBzdWNjZXNzTWVzc2FnZT86IHN0cmluZztcblxuICAvKiogQ29tcGFjdCBtb2RlIChsZXNzIHNwYWNpbmcpICovXG4gIGNvbXBhY3Q/OiBib29sZWFuO1xuXG4gIC8qKiBBZGRpdGlvbmFsIENTUyBjbGFzcyBmb3IgdGhlIHdyYXBwZXIgKi9cbiAgY3NzQ2xhc3M/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVxdWVzdFN1Ym1pdEV2ZW50IHtcbiAgcmVxdWVzdElkOiBzdHJpbmc7XG4gIHJlcXVlc3Q6IEFwcFJlcXVlc3Q7XG4gIHR5cGU6IHN0cmluZztcbiAgdGl0bGU6IHN0cmluZztcbiAgYXR0YWNobWVudFVybHM/OiBzdHJpbmdbXTtcbn1cbiJdfQ==