valtech-components 4.0.982 → 4.0.984

package/esm2022/lib/components/atoms/button/button.component.mjs

@@ -151,6 +151,7 @@ export class ButtonComponent {
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ButtonComponent, isStandalone: true, selector: "val-button", inputs: { preset: "preset", props: "props" }, outputs: { onClick: "onClick" }, usesOnChanges: true, ngImport: i0, template: `
     <ion-button
       [attr.data-testid]="resolvedProps.token"
+      [attr.aria-label]="resolvedProps.ariaLabel || null"
       [type]="resolvedProps.type"
       [color]="resolvedProps.color"
       [expand]="resolvedProps.expand"
@@ -180,6 +181,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             args: [{ selector: 'val-button', standalone: true, imports: [CommonModule, RouterLink, IonButton, IonIcon, IonSpinner, IonText], template: `
     <ion-button
       [attr.data-testid]="resolvedProps.token"
+      [attr.aria-label]="resolvedProps.ariaLabel || null"
       [type]="resolvedProps.type"
       [color]="resolvedProps.color"
       [expand]="resolvedProps.expand"
@@ -210,4 +212,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], onClick: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/atoms/button/button.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAqB,MAAM,EAAiB,MAAM,eAAe,CAAC;AACjH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAIpF,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAkB,eAAe,EAAE,MAAM,aAAa,CAAC;;;;;;AAkC1E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,eAAe;IAU1B;;;;;;;OAOG;IACH,WAAW;QACT,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,IAAI,IAAI,CAAC,aAAa,EAAE,IAAI;YAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACpE,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,aAAa,EAAE,IAAI;YAAE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC7E,IAAI,IAAI,CAAC,aAAa,EAAE,IAAI,KAAK,MAAM;YAAE,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACrE,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,aAAa,EAAE,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC;IAClF,CAAC;IA6BD,YACU,QAAyB,EACjC,KAAkB,EACV,UAA6B;QAF7B,aAAQ,GAAR,QAAQ,CAAiB;QAEzB,eAAU,GAAV,UAAU,CAAmB;QAhEvC,WAAM,GAAG,eAAe,CAAC;QAEjB,YAAO,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QAExC;;WAEG;QACH,gBAAW,GAAW,EAAE,CAAC;QAoCzB;;;WAGG;QACM,UAAK,GAA4B,EAAE,CAAC;QAE7C;;;WAGG;QACH,kBAAa,GAAmB,EAAoB,CAAC;QAErD;;WAEG;QAEH,YAAO,GAAG,IAAI,YAAY,EAAU,CAAC;IAMlC,CAAC;IAEJ,QAAQ;QACN,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,YAAY;QAClB,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAA6B,CAAC,CAAC,CAAC,EAAE,CAAC;QAE5G,0CAA0C;QAC1C,IAAI,CAAC,aAAa,GAAG;YACnB,GAAG,WAAW;YACd,GAAG,IAAI,CAAC,KAAK;SACI,CAAC;IACtB,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,aAAa,CAAC,oBAAoB,EAAE,CAAC;gBAC5C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;YAC/G,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAC7C,CAAC;QACH,CAAC;aAAM,IAAI,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC;YAC9C,gEAAgE;YAChE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC;QACxD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QACxB,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,kBAAkB,CAAC,OAAe,EAAE,MAA2B;QACrE,OAAO,OAAO,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACtD,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACjE,CAAC,CAAC,CAAC;IACL,CAAC;IAED,YAAY;QACV,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACtD,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,KAAK,UAAU,CAAC,cAAc,EAAE,CAAC;YAChE,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAChC,IAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;YAC/B,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;+GA5IU,eAAe;mGAAf,eAAe,0KAjDhB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBT,wiKA1BS,YAAY,iOAAE,UAAU,oOAAE,SAAS,oPAAE,OAAO,2JAAE,UAAU,yGAAE,OAAO;;4FAkDhE,eAAe;kBArD3B,SAAS;+BACE,YAAY,cACV,IAAI,WACP,CAAC,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,CAAC,YAClE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBT;8IAkEQ,MAAM;sBAAd,KAAK;gBAMG,KAAK;sBAAb,KAAK;gBAYN,OAAO;sBADN,MAAM","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, inject, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';\nimport { RouterLink } from '@angular/router';\nimport { IonButton, IonIcon, IonSpinner, IonText } from '@ionic/angular/standalone';\nimport { DownloadService } from '../../../services/download.service';\nimport { IconService } from '../../../services/icons.service';\nimport { NavigationService } from '../../../services/navigation';\nimport { PresetService } from '../../../services/presets';\nimport { ActionType, ButtonMetadata, ComponentStates } from '../../types';\n\n@Component({\n  selector: 'val-button',\n  standalone: true,\n  imports: [CommonModule, RouterLink, IonButton, IonIcon, IonSpinner, IonText],\n  template: `\n    <ion-button\n      [attr.data-testid]=\"resolvedProps.token\"\n      [type]=\"resolvedProps.type\"\n      [color]=\"resolvedProps.color\"\n      [expand]=\"resolvedProps.expand\"\n      [fill]=\"ionFill()\"\n      [size]=\"resolvedProps.size\"\n      [href]=\"resolvedProps.href\"\n      [routerLink]=\"resolvedProps.routerLink ?? null\"\n      [target]=\"resolvedProps.target\"\n      [shape]=\"resolvedProps.shape\"\n      (click)=\"clickHandler()\"\n      [disabled]=\"resolvedProps.state === states.DISABLED\"\n      [ngClass]=\"sizeClasses()\"\n    >\n      <ion-icon\n        *ngIf=\"resolvedProps.icon\"\n        [slot]=\"resolvedProps.icon.slot\"\n        [name]=\"resolvedProps.icon.name\"\n        aria-hidden=\"true\"\n      ></ion-icon>\n      <ion-spinner *ngIf=\"resolvedProps.state === states.WORKING\" name=\"circular\" aria-label=\"Cargando\"></ion-spinner>\n      <ion-text *ngIf=\"resolvedProps.state !== states.WORKING\">{{ displayText }}</ion-text>\n    </ion-button>\n  `,\n  styleUrls: ['./button.component.scss'],\n})\n/**\n * val-button\n *\n * A customizable button supporting icons, loading state, navigation, and presets.\n *\n * @example With preset (recommended with i18n):\n * <val-button preset=\"primary-action\" [props]=\"{ text: 'Submit' | t }\"></val-button>\n *\n * @example Static text:\n * <val-button [props]=\"{\n *   text: 'Save',\n *   color: 'primary',\n *   type: 'button',\n *   state: 'ENABLED',\n *   icon: { name: 'save', slot: 'start' }\n * }\" (onClick)=\"handler()\"></val-button>\n *\n * @input preset: string - Name of preset to apply (e.g., 'primary-action', 'danger')\n * @input props: ButtonMetadata - Configuration for the button (overrides preset values)\n * @output onClick - Emits when the button is clicked\n */\nexport class ButtonComponent implements OnInit, OnChanges {\n  states = ComponentStates;\n\n  private presets = inject(PresetService);\n\n  /**\n   * The text to display on the button.\n   */\n  displayText: string = '';\n\n  /**\n   * Clases de tamaño del botón.\n   *\n   * `icon-only` se DERIVA de que no haya texto en vez de pedirse por prop: un\n   * botón sin texto ya declaró todo lo que hacía falta saber, y una prop extra\n   * solo agrega una forma de que alguien la olvide y el botón salga como cápsula\n   * estirada. Ver la escala en button.component.scss.\n   */\n  sizeClasses(): string[] {\n    const classes: string[] = [];\n    if (this.resolvedProps?.size) classes.push(this.resolvedProps.size);\n    if (!this.displayText && this.resolvedProps?.icon) classes.push('icon-only');\n    if (this.resolvedProps?.fill === 'tint') classes.push('button-tint');\n    return classes;\n  }\n\n  /**\n   * `tint` no existe en Ionic — se renderiza como `clear` (sin fondo/borde\n   * propios de Ionic) y la superficie tenue la aporta `.button-tint` en el\n   * SCSS, vía la clase que agrega `sizeClasses()`.\n   */\n  ionFill(): 'clear' | 'outline' | 'solid' | 'default' | undefined {\n    return this.resolvedProps?.fill === 'tint' ? 'clear' : this.resolvedProps?.fill;\n  }\n\n  /**\n   * Preset name to apply. Presets define reusable button configurations\n   * (size, color, fill, etc.) that can be registered at app level.\n   *\n   * @example\n   * <val-button preset=\"primary-action\" [props]=\"{ text: 'Save' }\"></val-button>\n   */\n  @Input() preset?: string;\n\n  /**\n   * Button configuration. Values here override preset values.\n   * When using presets, only partial props are needed (preset provides defaults).\n   */\n  @Input() props: Partial<ButtonMetadata> = {};\n\n  /**\n   * Resolved props after merging preset + explicit props.\n   * Preset values are overridden by explicit props.\n   */\n  resolvedProps: ButtonMetadata = {} as ButtonMetadata;\n\n  /**\n   * Event emitted when the button is clicked.\n   */\n  @Output()\n  onClick = new EventEmitter<string>();\n\n  constructor(\n    private download: DownloadService,\n    _icon: IconService,\n    private navigation: NavigationService\n  ) {}\n\n  ngOnInit() {\n    this.resolveProps();\n    this.setupDisplayText();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['preset'] || changes['props']) {\n      this.resolveProps();\n      this.setupDisplayText();\n    }\n  }\n\n  /**\n   * Merge preset configuration with explicit props.\n   * Explicit props take precedence over preset values.\n   */\n  private resolveProps(): void {\n    const presetProps = this.preset ? (this.presets.get('button', this.preset) as Partial<ButtonMetadata>) : {};\n\n    // Merge: preset defaults < explicit props\n    this.resolvedProps = {\n      ...presetProps,\n      ...this.props,\n    } as ButtonMetadata;\n  }\n\n  /**\n   * Set up the text content based on the resolved props configuration.\n   */\n  private setupDisplayText(): void {\n    if (this.resolvedProps.text) {\n      if (this.resolvedProps.contentInterpolation) {\n        this.displayText = this.interpolateContent(this.resolvedProps.text, this.resolvedProps.contentInterpolation);\n      } else {\n        this.displayText = this.resolvedProps.text;\n      }\n    } else if (this.resolvedProps.contentFallback) {\n      // Backwards compatibility: use fallback if text is not provided\n      this.displayText = this.resolvedProps.contentFallback;\n    } else {\n      this.displayText = '';\n    }\n  }\n\n  /**\n   * Interpolate placeholders in content with provided values.\n   * Supports {{placeholder}} format.\n   */\n  private interpolateContent(content: string, values: Record<string, any>): string {\n    return content.replace(/\\{\\{(\\w+)\\}\\}/g, (match, key) => {\n      return values[key] !== undefined ? String(values[key]) : match;\n    });\n  }\n\n  clickHandler() {\n    if (this.resolvedProps.state === this.states.DISABLED) {\n      return;\n    }\n\n    if (this.resolvedProps.actionType === ActionType.APP_NAVIGATION) {\n      this.navigation.navigateByUrl(this.resolvedProps.link);\n    }\n\n    if (this.resolvedProps.download) {\n      this.download.downloadLinkFromBrowser(this.resolvedProps.download);\n    }\n\n    if (this.resolvedProps.handler) {\n      this.resolvedProps.handler(this.resolvedProps.ref);\n    }\n\n    this.onClick.emit(this.resolvedProps.token);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/atoms/button/button.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, inject, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';\nimport { RouterLink } from '@angular/router';\nimport { IonButton, IonIcon, IonSpinner, IonText } from '@ionic/angular/standalone';\nimport { DownloadService } from '../../../services/download.service';\nimport { IconService } from '../../../services/icons.service';\nimport { NavigationService } from '../../../services/navigation';\nimport { PresetService } from '../../../services/presets';\nimport { ActionType, ButtonMetadata, ComponentStates } from '../../types';\n\n@Component({\n  selector: 'val-button',\n  standalone: true,\n  imports: [CommonModule, RouterLink, IonButton, IonIcon, IonSpinner, IonText],\n  template: `\n    <ion-button\n      [attr.data-testid]=\"resolvedProps.token\"\n      [attr.aria-label]=\"resolvedProps.ariaLabel || null\"\n      [type]=\"resolvedProps.type\"\n      [color]=\"resolvedProps.color\"\n      [expand]=\"resolvedProps.expand\"\n      [fill]=\"ionFill()\"\n      [size]=\"resolvedProps.size\"\n      [href]=\"resolvedProps.href\"\n      [routerLink]=\"resolvedProps.routerLink ?? null\"\n      [target]=\"resolvedProps.target\"\n      [shape]=\"resolvedProps.shape\"\n      (click)=\"clickHandler()\"\n      [disabled]=\"resolvedProps.state === states.DISABLED\"\n      [ngClass]=\"sizeClasses()\"\n    >\n      <ion-icon\n        *ngIf=\"resolvedProps.icon\"\n        [slot]=\"resolvedProps.icon.slot\"\n        [name]=\"resolvedProps.icon.name\"\n        aria-hidden=\"true\"\n      ></ion-icon>\n      <ion-spinner *ngIf=\"resolvedProps.state === states.WORKING\" name=\"circular\" aria-label=\"Cargando\"></ion-spinner>\n      <ion-text *ngIf=\"resolvedProps.state !== states.WORKING\">{{ displayText }}</ion-text>\n    </ion-button>\n  `,\n  styleUrls: ['./button.component.scss'],\n})\n/**\n * val-button\n *\n * A customizable button supporting icons, loading state, navigation, and presets.\n *\n * @example With preset (recommended with i18n):\n * <val-button preset=\"primary-action\" [props]=\"{ text: 'Submit' | t }\"></val-button>\n *\n * @example Static text:\n * <val-button [props]=\"{\n *   text: 'Save',\n *   color: 'primary',\n *   type: 'button',\n *   state: 'ENABLED',\n *   icon: { name: 'save', slot: 'start' }\n * }\" (onClick)=\"handler()\"></val-button>\n *\n * @input preset: string - Name of preset to apply (e.g., 'primary-action', 'danger')\n * @input props: ButtonMetadata - Configuration for the button (overrides preset values)\n * @output onClick - Emits when the button is clicked\n */\nexport class ButtonComponent implements OnInit, OnChanges {\n  states = ComponentStates;\n\n  private presets = inject(PresetService);\n\n  /**\n   * The text to display on the button.\n   */\n  displayText: string = '';\n\n  /**\n   * Clases de tamaño del botón.\n   *\n   * `icon-only` se DERIVA de que no haya texto en vez de pedirse por prop: un\n   * botón sin texto ya declaró todo lo que hacía falta saber, y una prop extra\n   * solo agrega una forma de que alguien la olvide y el botón salga como cápsula\n   * estirada. Ver la escala en button.component.scss.\n   */\n  sizeClasses(): string[] {\n    const classes: string[] = [];\n    if (this.resolvedProps?.size) classes.push(this.resolvedProps.size);\n    if (!this.displayText && this.resolvedProps?.icon) classes.push('icon-only');\n    if (this.resolvedProps?.fill === 'tint') classes.push('button-tint');\n    return classes;\n  }\n\n  /**\n   * `tint` no existe en Ionic — se renderiza como `clear` (sin fondo/borde\n   * propios de Ionic) y la superficie tenue la aporta `.button-tint` en el\n   * SCSS, vía la clase que agrega `sizeClasses()`.\n   */\n  ionFill(): 'clear' | 'outline' | 'solid' | 'default' | undefined {\n    return this.resolvedProps?.fill === 'tint' ? 'clear' : this.resolvedProps?.fill;\n  }\n\n  /**\n   * Preset name to apply. Presets define reusable button configurations\n   * (size, color, fill, etc.) that can be registered at app level.\n   *\n   * @example\n   * <val-button preset=\"primary-action\" [props]=\"{ text: 'Save' }\"></val-button>\n   */\n  @Input() preset?: string;\n\n  /**\n   * Button configuration. Values here override preset values.\n   * When using presets, only partial props are needed (preset provides defaults).\n   */\n  @Input() props: Partial<ButtonMetadata> = {};\n\n  /**\n   * Resolved props after merging preset + explicit props.\n   * Preset values are overridden by explicit props.\n   */\n  resolvedProps: ButtonMetadata = {} as ButtonMetadata;\n\n  /**\n   * Event emitted when the button is clicked.\n   */\n  @Output()\n  onClick = new EventEmitter<string>();\n\n  constructor(\n    private download: DownloadService,\n    _icon: IconService,\n    private navigation: NavigationService\n  ) {}\n\n  ngOnInit() {\n    this.resolveProps();\n    this.setupDisplayText();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['preset'] || changes['props']) {\n      this.resolveProps();\n      this.setupDisplayText();\n    }\n  }\n\n  /**\n   * Merge preset configuration with explicit props.\n   * Explicit props take precedence over preset values.\n   */\n  private resolveProps(): void {\n    const presetProps = this.preset ? (this.presets.get('button', this.preset) as Partial<ButtonMetadata>) : {};\n\n    // Merge: preset defaults < explicit props\n    this.resolvedProps = {\n      ...presetProps,\n      ...this.props,\n    } as ButtonMetadata;\n  }\n\n  /**\n   * Set up the text content based on the resolved props configuration.\n   */\n  private setupDisplayText(): void {\n    if (this.resolvedProps.text) {\n      if (this.resolvedProps.contentInterpolation) {\n        this.displayText = this.interpolateContent(this.resolvedProps.text, this.resolvedProps.contentInterpolation);\n      } else {\n        this.displayText = this.resolvedProps.text;\n      }\n    } else if (this.resolvedProps.contentFallback) {\n      // Backwards compatibility: use fallback if text is not provided\n      this.displayText = this.resolvedProps.contentFallback;\n    } else {\n      this.displayText = '';\n    }\n  }\n\n  /**\n   * Interpolate placeholders in content with provided values.\n   * Supports {{placeholder}} format.\n   */\n  private interpolateContent(content: string, values: Record<string, any>): string {\n    return content.replace(/\\{\\{(\\w+)\\}\\}/g, (match, key) => {\n      return values[key] !== undefined ? String(values[key]) : match;\n    });\n  }\n\n  clickHandler() {\n    if (this.resolvedProps.state === this.states.DISABLED) {\n      return;\n    }\n\n    if (this.resolvedProps.actionType === ActionType.APP_NAVIGATION) {\n      this.navigation.navigateByUrl(this.resolvedProps.link);\n    }\n\n    if (this.resolvedProps.download) {\n      this.download.downloadLinkFromBrowser(this.resolvedProps.download);\n    }\n\n    if (this.resolvedProps.handler) {\n      this.resolvedProps.handler(this.resolvedProps.ref);\n    }\n\n    this.onClick.emit(this.resolvedProps.token);\n  }\n}\n"]}

package/esm2022/lib/components/organisms/field-schema-editor/field-schema-editor.component.mjs

@@ -0,0 +1,364 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Input, Output, computed, inject, signal } from '@angular/core';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { I18nService } from '../../../services/i18n';
+import { FormSchemaBuilderService } from '../../../services/forms/form-schema-builder.service';
+import { ComponentStates, InputType } from '../../types';
+import { FormFieldComponent } from '../../molecules/form-field/form-field.component';
+import { TextInputComponent } from '../../molecules/text-input/text-input.component';
+import { TextareaInputComponent } from '../../molecules/textarea-input/textarea-input.component';
+import { SearchSelectorComponent } from '../../molecules/select-input/select-input.component';
+import { ToggleInputComponent } from '../../molecules/toggle-input/toggle-input.component';
+import { FieldOptionsEditorComponent } from '../../molecules/field-options-editor/field-options-editor.component';
+import { FIELD_SCHEMA_EDITOR_I18N } from './field-schema-editor.i18n';
+import * as i0 from "@angular/core";
+const NAMESPACE = 'FieldSchemaEditor';
+/**
+ * Tipos cuyo valor sale de una lista cerrada que define quien arma el
+ * formulario — sin al menos una opción, el campo no se puede responder.
+ * Espejo de `fieldRequiresOptions` que vivía duplicado en bingo.
+ */
+export const FIELD_TYPES_WITH_OPTIONS = ['SELECT', 'RADIO', 'MULTI_SELECT'];
+let fieldUid = 0;
+/**
+ * val-field-schema-editor
+ *
+ * Edita UN campo de un formulario dinámico: texto, tipo, placeholder, nota,
+ * obligatoriedad y opciones. Es la pieza que faltaba en la lib — hasta ahora
+ * el único editor de campos con este nivel vivía dentro de bingo
+ * (`checkout-field-modal.component.ts`), invisible para el resto del factory,
+ * y `val-survey-builder` había terminado con una versión pobre de lo mismo
+ * (dos tipos fijos, sin placeholder ni opciones).
+ *
+ * Es agnóstico de dominio a propósito:
+ * - el **catálogo de tipos** (`allowedTypes`) lo decide el consumer, porque es
+ *   él quien sabe qué sabe renderizar su formulario;
+ * - los **presets** los pasa el consumer, porque "correo del comprador" es de
+ *   checkout y no significa nada en una encuesta.
+ *
+ * No trae cáscara de modal: el consumer lo envuelve en `val-modal-layout` (o
+ * en lo que quiera) y dispara `submit()` desde su propio botón, igual que hace
+ * `survey-create-modal` con `val-survey-builder`.
+ */
+export class FieldSchemaEditorComponent {
+    constructor() {
+        this.props = { allowedTypes: ['TEXT'] };
+        this.save = new EventEmitter();
+        /**
+         * Emite en cada tecla, sin validar. Existe porque el consumer necesita el
+         * borrador en vivo: si solo tuviera `save`, lo escrito acá no existiría para
+         * él hasta que alguien toque su botón — y lo escrito ES la intención del
+         * usuario, no un borrador que haya que confirmar.
+         */
+        this.changed = new EventEmitter();
+        this.i18n = inject(I18nService);
+        this.formSchemas = inject(FormSchemaBuilderService);
+        this.labelControl = new FormControl('', { nonNullable: true });
+        this.placeholderControl = new FormControl('', { nonNullable: true });
+        this.hintControl = new FormControl('', { nonNullable: true });
+        this.requiredControl = new FormControl(true, { nonNullable: true });
+        this.typeControl = new FormControl('TEXT', { nonNullable: true });
+        this.options = signal([]);
+        this.validationError = signal('');
+        this.selectedPresetId = signal('');
+        /** Se refresca con cada cambio de tipo — `needsOptions` no puede leer el control directo. */
+        this.currentType = signal('TEXT');
+        /** Una vez que se toca el token a mano (o se edita un campo ya guardado) deja de derivarse del label. */
+        this.nameLocked = false;
+        this.name = '';
+        this.fieldId = '';
+        this.typeSelectProps = computed(() => {
+            this.i18n.lang();
+            return {
+                control: this.typeControl,
+                type: InputType.SELECT,
+                state: this.state(),
+                placeholder: this.t('typeLabel'),
+                // action-sheet y no el popover default de Ionic: el popover se ancla al
+                // campo, y con el campo cerca del borde inferior y un catálogo largo
+                // Ionic lo recorta arriba Y abajo — quedaban tipos imposibles de elegir.
+                // La hoja usa el alto completo y scrollea sola.
+                selectInterface: 'action-sheet',
+                options: this.allowedTypes().map((type, order) => ({ id: type, name: this.typeLabel(type), order })),
+            };
+        });
+        this.optionsEditorProps = computed(() => {
+            this.i18n.lang();
+            return {
+                title: this.t('optionsTitle'),
+                hint: this.t('optionsHint'),
+                addLabel: this.t('optionsAdd'),
+                optionsLabel: this.t('optionsList'),
+                placeholder: this.t('optionsPlaceholder'),
+                emptyText: this.t('optionsEmpty'),
+                removeOptionLabel: this.t('optionsRemove'),
+                reorderOptionLabel: this.t('optionsReorder'),
+                state: this.state(),
+                options: this.options(),
+            };
+        });
+        if (!this.i18n.hasNamespace(NAMESPACE)) {
+            this.i18n.registerDefaults(NAMESPACE, FIELD_SCHEMA_EDITOR_I18N);
+        }
+        this.typeControl.valueChanges.subscribe(value => {
+            this.currentType.set(value || 'TEXT');
+            this.emitChange();
+        });
+        this.labelControl.valueChanges.subscribe(value => {
+            if (!this.nameLocked)
+                this.name = this.formSchemas.toToken(value || '');
+            this.emitChange();
+        });
+        this.placeholderControl.valueChanges.subscribe(() => this.emitChange());
+        this.hintControl.valueChanges.subscribe(() => this.emitChange());
+        this.requiredControl.valueChanges.subscribe(() => this.emitChange());
+    }
+    ngOnInit() {
+        const initial = this.props.field;
+        if (initial) {
+            this.fieldId = initial.id;
+            this.nameLocked = true;
+            this.name = initial.name;
+            this.labelControl.setValue(initial.label ?? '');
+            this.placeholderControl.setValue(initial.placeholderText ?? '');
+            this.hintControl.setValue(initial.hintText ?? '');
+            this.requiredControl.setValue(!!initial.required);
+            this.typeControl.setValue(this.coerceType(initial.type));
+            this.options.set(initial.options ?? []);
+            return;
+        }
+        this.fieldId = `field-${++fieldUid}`;
+        this.typeControl.setValue(this.coerceType(this.typeControl.value));
+        const first = this.props.presets?.[0];
+        if (first)
+            this.selectPreset(first);
+    }
+    t(key) {
+        this.i18n.lang();
+        return this.i18n.t(key, NAMESPACE);
+    }
+    state() {
+        return this.props.state ?? ComponentStates.ENABLED;
+    }
+    showPresets() {
+        return this.props.mode !== 'edit' && !!this.props.presets?.length;
+    }
+    needsOptions() {
+        return FIELD_TYPES_WITH_OPTIONS.includes(this.currentType());
+    }
+    typeLabel(type) {
+        return this.props.typeLabels?.[type] || this.t(`type${type}`);
+    }
+    setOptions(options) {
+        this.options.set(options);
+        this.emitChange();
+    }
+    emitChange() {
+        // Antes de ngOnInit no hay id: emitir ahí daría un campo sin identidad, que
+        // el consumer no sabría a qué fila aplicar.
+        if (this.fieldId)
+            this.changed.emit(this.value());
+    }
+    selectPreset(preset) {
+        this.selectedPresetId.set(preset.id);
+        const value = preset.field;
+        // El preset fija el token: "correo del comprador" tiene que llamarse
+        // `email` aunque después le cambien el texto visible.
+        this.nameLocked = !!value.name;
+        this.name = value.name || this.formSchemas.toToken(value.label || '');
+        this.labelControl.setValue(value.label ?? '');
+        this.placeholderControl.setValue(value.placeholderText ?? '');
+        this.hintControl.setValue(value.hintText ?? '');
+        this.requiredControl.setValue(!!value.required);
+        this.typeControl.setValue(this.coerceType(value.type));
+        this.options.set(value.options ?? []);
+        this.emitChange();
+    }
+    /**
+     * Valida y emite. Público a propósito: lo llama el consumer desde el botón
+     * de su propia cáscara (modal, página o acordeón).
+     */
+    submit() {
+        const field = this.value();
+        if (!field.label || !field.name || !field.type) {
+            this.validationError.set(this.t('errorIncomplete'));
+            return false;
+        }
+        if (this.needsOptions() && !(field.options?.length ?? 0)) {
+            this.validationError.set(this.t('errorOptionsRequired'));
+            return false;
+        }
+        this.validationError.set('');
+        this.save.emit(field);
+        return true;
+    }
+    /** El campo tal como está en pantalla, sin validar. */
+    value() {
+        const label = (this.labelControl.value || '').trim();
+        return {
+            id: this.fieldId,
+            name: this.formSchemas.toToken(this.name || label),
+            label,
+            placeholderText: (this.placeholderControl.value || '').trim(),
+            hintText: (this.hintControl.value || '').trim(),
+            type: this.coerceType(this.typeControl.value),
+            required: this.requiredControl.value,
+            options: this.needsOptions() ? this.options().map((option, index) => ({ ...option, order: index })) : undefined,
+        };
+    }
+    allowedTypes() {
+        return this.props.allowedTypes?.length ? this.props.allowedTypes : ['TEXT'];
+    }
+    /**
+     * Un tipo fuera del catálogo del consumer cae al primero permitido. Pasa al
+     * editar un campo guardado con un tipo que la app ya no ofrece (bingo lo
+     * hacía con ATTACHMENT cuando el medio de pago no lo admite): sin esto, el
+     * select queda en un valor que no está en su lista y se ve vacío.
+     */
+    coerceType(type) {
+        const allowed = this.allowedTypes();
+        return allowed.includes(type) ? type : allowed[0];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldSchemaEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: FieldSchemaEditorComponent, isStandalone: true, selector: "val-field-schema-editor", inputs: { props: "props" }, outputs: { save: "save", changed: "changed" }, ngImport: i0, template: `
+    <div class="field-schema-editor">
+      @if (showPresets()) {
+        <section class="field-schema-editor__presets">
+          <span class="field-schema-editor__section-label">{{ props.presetsTitle || t('presetsTitle') }}</span>
+          <div class="field-schema-editor__preset-grid">
+            @for (preset of props.presets; track preset.id) {
+              <button
+                type="button"
+                class="field-schema-editor__preset"
+                [class.field-schema-editor__preset--selected]="selectedPresetId() === preset.id"
+                (click)="selectPreset(preset)"
+              >
+                <strong>{{ preset.label }}</strong>
+                @if (preset.description) {
+                  <span>{{ preset.description }}</span>
+                }
+              </button>
+            }
+          </div>
+        </section>
+      }
+
+      <val-form-field [label]="t('labelLabel')">
+        <val-text-input [props]="{ control: labelControl, placeholder: t('labelPlaceholder'), state: state() }" />
+      </val-form-field>
+
+      <val-form-field [label]="t('typeLabel')">
+        <val-select-input [props]="typeSelectProps()" />
+      </val-form-field>
+
+      @if (props.showPlaceholder !== false) {
+        <val-form-field [label]="t('placeholderLabel')">
+          <val-textarea-input [props]="{ control: placeholderControl, autoGrow: true, state: state() }" />
+        </val-form-field>
+      }
+
+      @if (props.showHint !== false) {
+        <val-form-field [label]="t('hintLabel')">
+          <val-textarea-input [props]="{ control: hintControl, autoGrow: true, state: state() }" />
+        </val-form-field>
+      }
+
+      <val-toggle-input
+        [props]="{
+          control: requiredControl,
+          label: t('requiredLabel'),
+          justify: 'space-between',
+          state: state(),
+        }"
+      />
+
+      @if (needsOptions()) {
+            <val-field-options-editor [props]="optionsEditorProps()" (optionsChange)="setOptions($event)" />
+      }
+
+      @if (validationError()) {
+        <p class="field-schema-editor__error">{{ validationError() }}</p>
+      }
+    </div>
+  `, isInline: true, styles: [":host{display:block}.field-schema-editor{display:flex;flex-direction:column;gap:12px}.field-schema-editor__presets{display:flex;flex-direction:column;gap:8px}.field-schema-editor__section-label{font-size:.8125rem;font-weight:700;letter-spacing:.04em;text-transform:uppercase;color:var(--ion-color-medium, #92949c)}.field-schema-editor__preset-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:10px}.field-schema-editor__preset{min-height:80px;padding:12px;border:1px solid var(--val-border-color, var(--ion-border-color, rgba(0, 0, 0, .1)));border-radius:var(--val-radius-md, 12px);background:var(--ion-card-background, var(--ion-background-color, #fff));color:var(--ion-text-color);text-align:left;cursor:pointer}.field-schema-editor__preset strong,.field-schema-editor__preset span{display:block}.field-schema-editor__preset span{margin-top:4px;font-size:.8125rem;line-height:1.3;color:var(--ion-color-medium, #92949c)}.field-schema-editor__preset--selected{border-color:var(--ion-color-primary);box-shadow:0 0 0 2px rgba(var(--ion-color-primary-rgb, 255, 0, 178),.14)}.field-schema-editor__error{margin:0;color:var(--ion-color-danger);font-size:.875rem;font-weight:700}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "component", type: FormFieldComponent, selector: "val-form-field", inputs: ["label"] }, { kind: "component", type: TextInputComponent, selector: "val-text-input", inputs: ["preset", "props"] }, { kind: "component", type: TextareaInputComponent, selector: "val-textarea-input", inputs: ["preset", "props"] }, { kind: "component", type: SearchSelectorComponent, selector: "val-select-input", inputs: ["preset", "props"] }, { kind: "component", type: ToggleInputComponent, selector: "val-toggle-input", inputs: ["preset", "props"] }, { kind: "component", type: FieldOptionsEditorComponent, selector: "val-field-options-editor", inputs: ["props"], outputs: ["optionsChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FieldSchemaEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-field-schema-editor', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormFieldComponent,
+                        TextInputComponent,
+                        TextareaInputComponent,
+                        SearchSelectorComponent,
+                        ToggleInputComponent,
+                        FieldOptionsEditorComponent,
+                    ], template: `
+    <div class="field-schema-editor">
+      @if (showPresets()) {
+        <section class="field-schema-editor__presets">
+          <span class="field-schema-editor__section-label">{{ props.presetsTitle || t('presetsTitle') }}</span>
+          <div class="field-schema-editor__preset-grid">
+            @for (preset of props.presets; track preset.id) {
+              <button
+                type="button"
+                class="field-schema-editor__preset"
+                [class.field-schema-editor__preset--selected]="selectedPresetId() === preset.id"
+                (click)="selectPreset(preset)"
+              >
+                <strong>{{ preset.label }}</strong>
+                @if (preset.description) {
+                  <span>{{ preset.description }}</span>
+                }
+              </button>
+            }
+          </div>
+        </section>
+      }
+
+      <val-form-field [label]="t('labelLabel')">
+        <val-text-input [props]="{ control: labelControl, placeholder: t('labelPlaceholder'), state: state() }" />
+      </val-form-field>
+
+      <val-form-field [label]="t('typeLabel')">
+        <val-select-input [props]="typeSelectProps()" />
+      </val-form-field>
+
+      @if (props.showPlaceholder !== false) {
+        <val-form-field [label]="t('placeholderLabel')">
+          <val-textarea-input [props]="{ control: placeholderControl, autoGrow: true, state: state() }" />
+        </val-form-field>
+      }
+
+      @if (props.showHint !== false) {
+        <val-form-field [label]="t('hintLabel')">
+          <val-textarea-input [props]="{ control: hintControl, autoGrow: true, state: state() }" />
+        </val-form-field>
+      }
+
+      <val-toggle-input
+        [props]="{
+          control: requiredControl,
+          label: t('requiredLabel'),
+          justify: 'space-between',
+          state: state(),
+        }"
+      />
+
+      @if (needsOptions()) {
+            <val-field-options-editor [props]="optionsEditorProps()" (optionsChange)="setOptions($event)" />
+      }
+
+      @if (validationError()) {
+        <p class="field-schema-editor__error">{{ validationError() }}</p>
+      }
+    </div>
+  `, styles: [":host{display:block}.field-schema-editor{display:flex;flex-direction:column;gap:12px}.field-schema-editor__presets{display:flex;flex-direction:column;gap:8px}.field-schema-editor__section-label{font-size:.8125rem;font-weight:700;letter-spacing:.04em;text-transform:uppercase;color:var(--ion-color-medium, #92949c)}.field-schema-editor__preset-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:10px}.field-schema-editor__preset{min-height:80px;padding:12px;border:1px solid var(--val-border-color, var(--ion-border-color, rgba(0, 0, 0, .1)));border-radius:var(--val-radius-md, 12px);background:var(--ion-card-background, var(--ion-background-color, #fff));color:var(--ion-text-color);text-align:left;cursor:pointer}.field-schema-editor__preset strong,.field-schema-editor__preset span{display:block}.field-schema-editor__preset span{margin-top:4px;font-size:.8125rem;line-height:1.3;color:var(--ion-color-medium, #92949c)}.field-schema-editor__preset--selected{border-color:var(--ion-color-primary);box-shadow:0 0 0 2px rgba(var(--ion-color-primary-rgb, 255, 0, 178),.14)}.field-schema-editor__error{margin:0;color:var(--ion-color-danger);font-size:.875rem;font-weight:700}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { props: [{
+                type: Input
+            }], save: [{
+                type: Output
+            }], changed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-schema-editor.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/field-schema-editor/field-schema-editor.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, Input, OnInit, Output, computed, inject, signal } from '@angular/core';\nimport { FormControl, ReactiveFormsModule } from '@angular/forms';\n\nimport { I18nService } from '../../../services/i18n';\nimport { FormSchemaBuilderService } from '../../../services/forms/form-schema-builder.service';\nimport { FieldOption } from '../../../services/forms/types';\nimport { ComponentStates, InputMetadata, InputType } from '../../types';\nimport { FormFieldComponent } from '../../molecules/form-field/form-field.component';\nimport { TextInputComponent } from '../../molecules/text-input/text-input.component';\nimport { TextareaInputComponent } from '../../molecules/textarea-input/textarea-input.component';\nimport { SearchSelectorComponent } from '../../molecules/select-input/select-input.component';\nimport { ToggleInputComponent } from '../../molecules/toggle-input/toggle-input.component';\nimport { FieldOptionsEditorComponent } from '../../molecules/field-options-editor/field-options-editor.component';\nimport { EditableFieldDef, FieldSchemaEditorMetadata, FieldSchemaEditorPreset } from './types';\nimport { FIELD_SCHEMA_EDITOR_I18N } from './field-schema-editor.i18n';\n\nconst NAMESPACE = 'FieldSchemaEditor';\n\n/**\n * Tipos cuyo valor sale de una lista cerrada que define quien arma el\n * formulario — sin al menos una opción, el campo no se puede responder.\n * Espejo de `fieldRequiresOptions` que vivía duplicado en bingo.\n */\nexport const FIELD_TYPES_WITH_OPTIONS = ['SELECT', 'RADIO', 'MULTI_SELECT'];\n\nlet fieldUid = 0;\n\n/**\n * val-field-schema-editor\n *\n * Edita UN campo de un formulario dinámico: texto, tipo, placeholder, nota,\n * obligatoriedad y opciones. Es la pieza que faltaba en la lib — hasta ahora\n * el único editor de campos con este nivel vivía dentro de bingo\n * (`checkout-field-modal.component.ts`), invisible para el resto del factory,\n * y `val-survey-builder` había terminado con una versión pobre de lo mismo\n * (dos tipos fijos, sin placeholder ni opciones).\n *\n * Es agnóstico de dominio a propósito:\n * - el **catálogo de tipos** (`allowedTypes`) lo decide el consumer, porque es\n *   él quien sabe qué sabe renderizar su formulario;\n * - los **presets** los pasa el consumer, porque \"correo del comprador\" es de\n *   checkout y no significa nada en una encuesta.\n *\n * No trae cáscara de modal: el consumer lo envuelve en `val-modal-layout` (o\n * en lo que quiera) y dispara `submit()` desde su propio botón, igual que hace\n * `survey-create-modal` con `val-survey-builder`.\n */\n@Component({\n  selector: 'val-field-schema-editor',\n  standalone: true,\n  imports: [\n    CommonModule,\n    ReactiveFormsModule,\n    FormFieldComponent,\n    TextInputComponent,\n    TextareaInputComponent,\n    SearchSelectorComponent,\n    ToggleInputComponent,\n    FieldOptionsEditorComponent,\n  ],\n  template: `\n    <div class=\"field-schema-editor\">\n      @if (showPresets()) {\n        <section class=\"field-schema-editor__presets\">\n          <span class=\"field-schema-editor__section-label\">{{ props.presetsTitle || t('presetsTitle') }}</span>\n          <div class=\"field-schema-editor__preset-grid\">\n            @for (preset of props.presets; track preset.id) {\n              <button\n                type=\"button\"\n                class=\"field-schema-editor__preset\"\n                [class.field-schema-editor__preset--selected]=\"selectedPresetId() === preset.id\"\n                (click)=\"selectPreset(preset)\"\n              >\n                <strong>{{ preset.label }}</strong>\n                @if (preset.description) {\n                  <span>{{ preset.description }}</span>\n                }\n              </button>\n            }\n          </div>\n        </section>\n      }\n\n      <val-form-field [label]=\"t('labelLabel')\">\n        <val-text-input [props]=\"{ control: labelControl, placeholder: t('labelPlaceholder'), state: state() }\" />\n      </val-form-field>\n\n      <val-form-field [label]=\"t('typeLabel')\">\n        <val-select-input [props]=\"typeSelectProps()\" />\n      </val-form-field>\n\n      @if (props.showPlaceholder !== false) {\n        <val-form-field [label]=\"t('placeholderLabel')\">\n          <val-textarea-input [props]=\"{ control: placeholderControl, autoGrow: true, state: state() }\" />\n        </val-form-field>\n      }\n\n      @if (props.showHint !== false) {\n        <val-form-field [label]=\"t('hintLabel')\">\n          <val-textarea-input [props]=\"{ control: hintControl, autoGrow: true, state: state() }\" />\n        </val-form-field>\n      }\n\n      <val-toggle-input\n        [props]=\"{\n          control: requiredControl,\n          label: t('requiredLabel'),\n          justify: 'space-between',\n          state: state(),\n        }\"\n      />\n\n      @if (needsOptions()) {\n            <val-field-options-editor [props]=\"optionsEditorProps()\" (optionsChange)=\"setOptions($event)\" />\n      }\n\n      @if (validationError()) {\n        <p class=\"field-schema-editor__error\">{{ validationError() }}</p>\n      }\n    </div>\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n      }\n      .field-schema-editor {\n        display: flex;\n        flex-direction: column;\n        gap: 12px;\n      }\n      .field-schema-editor__presets {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .field-schema-editor__section-label {\n        font-size: 0.8125rem;\n        font-weight: 700;\n        letter-spacing: 0.04em;\n        text-transform: uppercase;\n        color: var(--ion-color-medium, #92949c);\n      }\n      .field-schema-editor__preset-grid {\n        display: grid;\n        grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));\n        gap: 10px;\n      }\n      .field-schema-editor__preset {\n        min-height: 80px;\n        padding: 12px;\n        border: 1px solid var(--val-border-color, var(--ion-border-color, rgba(0, 0, 0, 0.1)));\n        border-radius: var(--val-radius-md, 12px);\n        background: var(--ion-card-background, var(--ion-background-color, #fff));\n        color: var(--ion-text-color);\n        text-align: left;\n        cursor: pointer;\n      }\n      .field-schema-editor__preset strong,\n      .field-schema-editor__preset span {\n        display: block;\n      }\n      .field-schema-editor__preset span {\n        margin-top: 4px;\n        font-size: 0.8125rem;\n        line-height: 1.3;\n        color: var(--ion-color-medium, #92949c);\n      }\n      .field-schema-editor__preset--selected {\n        border-color: var(--ion-color-primary);\n        box-shadow: 0 0 0 2px rgba(var(--ion-color-primary-rgb, 255, 0, 178), 0.14);\n      }\n      .field-schema-editor__error {\n        margin: 0;\n        color: var(--ion-color-danger);\n        font-size: 0.875rem;\n        font-weight: 700;\n      }\n    `,\n  ],\n})\nexport class FieldSchemaEditorComponent implements OnInit {\n  @Input() props: FieldSchemaEditorMetadata = { allowedTypes: ['TEXT'] };\n  @Output() readonly save = new EventEmitter<EditableFieldDef>();\n  /**\n   * Emite en cada tecla, sin validar. Existe porque el consumer necesita el\n   * borrador en vivo: si solo tuviera `save`, lo escrito acá no existiría para\n   * él hasta que alguien toque su botón — y lo escrito ES la intención del\n   * usuario, no un borrador que haya que confirmar.\n   */\n  @Output() readonly changed = new EventEmitter<EditableFieldDef>();\n\n  private readonly i18n = inject(I18nService);\n  private readonly formSchemas = inject(FormSchemaBuilderService);\n\n  readonly labelControl = new FormControl('', { nonNullable: true });\n  readonly placeholderControl = new FormControl('', { nonNullable: true });\n  readonly hintControl = new FormControl('', { nonNullable: true });\n  readonly requiredControl = new FormControl(true, { nonNullable: true });\n  readonly typeControl = new FormControl('TEXT', { nonNullable: true });\n\n  readonly options = signal<FieldOption[]>([]);\n  readonly validationError = signal('');\n  readonly selectedPresetId = signal('');\n  /** Se refresca con cada cambio de tipo — `needsOptions` no puede leer el control directo. */\n  private readonly currentType = signal('TEXT');\n  /** Una vez que se toca el token a mano (o se edita un campo ya guardado) deja de derivarse del label. */\n  private nameLocked = false;\n  private name = '';\n  private fieldId = '';\n\n  constructor() {\n    if (!this.i18n.hasNamespace(NAMESPACE)) {\n      this.i18n.registerDefaults(NAMESPACE, FIELD_SCHEMA_EDITOR_I18N);\n    }\n    this.typeControl.valueChanges.subscribe(value => {\n      this.currentType.set(value || 'TEXT');\n      this.emitChange();\n    });\n    this.labelControl.valueChanges.subscribe(value => {\n      if (!this.nameLocked) this.name = this.formSchemas.toToken(value || '');\n      this.emitChange();\n    });\n    this.placeholderControl.valueChanges.subscribe(() => this.emitChange());\n    this.hintControl.valueChanges.subscribe(() => this.emitChange());\n    this.requiredControl.valueChanges.subscribe(() => this.emitChange());\n  }\n\n  ngOnInit(): void {\n    const initial = this.props.field;\n    if (initial) {\n      this.fieldId = initial.id;\n      this.nameLocked = true;\n      this.name = initial.name;\n      this.labelControl.setValue(initial.label ?? '');\n      this.placeholderControl.setValue(initial.placeholderText ?? '');\n      this.hintControl.setValue(initial.hintText ?? '');\n      this.requiredControl.setValue(!!initial.required);\n      this.typeControl.setValue(this.coerceType(initial.type));\n      this.options.set(initial.options ?? []);\n      return;\n    }\n\n    this.fieldId = `field-${++fieldUid}`;\n    this.typeControl.setValue(this.coerceType(this.typeControl.value));\n    const first = this.props.presets?.[0];\n    if (first) this.selectPreset(first);\n  }\n\n  t(key: string): string {\n    this.i18n.lang();\n    return this.i18n.t(key, NAMESPACE);\n  }\n\n  state() {\n    return this.props.state ?? ComponentStates.ENABLED;\n  }\n\n  showPresets(): boolean {\n    return this.props.mode !== 'edit' && !!this.props.presets?.length;\n  }\n\n  needsOptions(): boolean {\n    return FIELD_TYPES_WITH_OPTIONS.includes(this.currentType());\n  }\n\n  typeLabel(type: string): string {\n    return this.props.typeLabels?.[type] || this.t(`type${type}`);\n  }\n\n  readonly typeSelectProps = computed<Partial<InputMetadata>>(() => {\n    this.i18n.lang();\n    return {\n      control: this.typeControl,\n      type: InputType.SELECT,\n      state: this.state(),\n      placeholder: this.t('typeLabel'),\n      // action-sheet y no el popover default de Ionic: el popover se ancla al\n      // campo, y con el campo cerca del borde inferior y un catálogo largo\n      // Ionic lo recorta arriba Y abajo — quedaban tipos imposibles de elegir.\n      // La hoja usa el alto completo y scrollea sola.\n      selectInterface: 'action-sheet',\n      options: this.allowedTypes().map((type, order) => ({ id: type, name: this.typeLabel(type), order })),\n    };\n  });\n\n  readonly optionsEditorProps = computed(() => {\n    this.i18n.lang();\n    return {\n      title: this.t('optionsTitle'),\n      hint: this.t('optionsHint'),\n      addLabel: this.t('optionsAdd'),\n      optionsLabel: this.t('optionsList'),\n      placeholder: this.t('optionsPlaceholder'),\n      emptyText: this.t('optionsEmpty'),\n      removeOptionLabel: this.t('optionsRemove'),\n      reorderOptionLabel: this.t('optionsReorder'),\n      state: this.state(),\n      options: this.options(),\n    };\n  });\n\n  setOptions(options: FieldOption[]): void {\n    this.options.set(options);\n    this.emitChange();\n  }\n\n  private emitChange(): void {\n    // Antes de ngOnInit no hay id: emitir ahí daría un campo sin identidad, que\n    // el consumer no sabría a qué fila aplicar.\n    if (this.fieldId) this.changed.emit(this.value());\n  }\n\n  selectPreset(preset: FieldSchemaEditorPreset): void {\n    this.selectedPresetId.set(preset.id);\n    const value = preset.field;\n    // El preset fija el token: \"correo del comprador\" tiene que llamarse\n    // `email` aunque después le cambien el texto visible.\n    this.nameLocked = !!value.name;\n    this.name = value.name || this.formSchemas.toToken(value.label || '');\n    this.labelControl.setValue(value.label ?? '');\n    this.placeholderControl.setValue(value.placeholderText ?? '');\n    this.hintControl.setValue(value.hintText ?? '');\n    this.requiredControl.setValue(!!value.required);\n    this.typeControl.setValue(this.coerceType(value.type));\n    this.options.set(value.options ?? []);\n    this.emitChange();\n  }\n\n  /**\n   * Valida y emite. Público a propósito: lo llama el consumer desde el botón\n   * de su propia cáscara (modal, página o acordeón).\n   */\n  submit(): boolean {\n    const field = this.value();\n    if (!field.label || !field.name || !field.type) {\n      this.validationError.set(this.t('errorIncomplete'));\n      return false;\n    }\n    if (this.needsOptions() && !(field.options?.length ?? 0)) {\n      this.validationError.set(this.t('errorOptionsRequired'));\n      return false;\n    }\n    this.validationError.set('');\n    this.save.emit(field);\n    return true;\n  }\n\n  /** El campo tal como está en pantalla, sin validar. */\n  value(): EditableFieldDef {\n    const label = (this.labelControl.value || '').trim();\n    return {\n      id: this.fieldId,\n      name: this.formSchemas.toToken(this.name || label),\n      label,\n      placeholderText: (this.placeholderControl.value || '').trim(),\n      hintText: (this.hintControl.value || '').trim(),\n      type: this.coerceType(this.typeControl.value),\n      required: this.requiredControl.value,\n      options: this.needsOptions() ? this.options().map((option, index) => ({ ...option, order: index })) : undefined,\n    };\n  }\n\n  private allowedTypes(): string[] {\n    return this.props.allowedTypes?.length ? this.props.allowedTypes : ['TEXT'];\n  }\n\n  /**\n   * Un tipo fuera del catálogo del consumer cae al primero permitido. Pasa al\n   * editar un campo guardado con un tipo que la app ya no ofrece (bingo lo\n   * hacía con ATTACHMENT cuando el medio de pago no lo admite): sin esto, el\n   * select queda en un valor que no está en su lista y se ve vacío.\n   */\n  private coerceType(type: string): string {\n    const allowed = this.allowedTypes();\n    return allowed.includes(type) ? type : allowed[0];\n  }\n}\n"]}

package/esm2022/lib/components/organisms/field-schema-editor/field-schema-editor.i18n.mjs

@@ -0,0 +1,71 @@
+export const FIELD_SCHEMA_EDITOR_I18N = {
+    es: {
+        presetsTitle: 'Empieza desde',
+        labelLabel: 'Texto del campo',
+        labelPlaceholder: 'Escribe lo que verá quien responde',
+        typeLabel: 'Tipo de campo',
+        placeholderLabel: 'Texto de ayuda dentro del campo',
+        hintLabel: 'Nota bajo el campo',
+        requiredLabel: 'Obligatorio',
+        optionsTitle: 'Opciones',
+        optionsHint: 'Estas son las alternativas que puede elegir quien responde.',
+        optionsAdd: 'Agregar opción',
+        optionsList: 'Opciones',
+        optionsPlaceholder: 'Escribe una opción',
+        optionsEmpty: 'Todavía no hay opciones.',
+        optionsRemove: 'Quitar opción',
+        optionsReorder: 'Reordenar opción',
+        errorIncomplete: 'Ponle un texto al campo y elige su tipo.',
+        errorOptionsRequired: 'Este tipo de campo necesita al menos una opción.',
+        typeTEXT: 'Texto corto',
+        typeTEXTAREA: 'Texto largo',
+        typeEMAIL: 'Correo',
+        typePHONE: 'Teléfono',
+        typeNUMBER: 'Número',
+        typeDATE: 'Fecha',
+        typeSELECT: 'Lista desplegable',
+        typeRADIO: 'Una sola opción',
+        typeMULTI_SELECT: 'Varias opciones',
+        typeCHECK: 'Casilla',
+        typeTOGGLE: 'Sí o no',
+        typeCURRENCY: 'Monto',
+        typeATTACHMENT: 'Archivo adjunto',
+        typeFILE: 'Archivo',
+        typeEMOJI_RATING: 'Calificación con emoji',
+    },
+    en: {
+        presetsTitle: 'Start from',
+        labelLabel: 'Field text',
+        labelPlaceholder: 'Write what the person will see',
+        typeLabel: 'Field type',
+        placeholderLabel: 'Helper text inside the field',
+        hintLabel: 'Note below the field',
+        requiredLabel: 'Required',
+        optionsTitle: 'Options',
+        optionsHint: 'These are the choices the person can pick.',
+        optionsAdd: 'Add option',
+        optionsList: 'Options',
+        optionsPlaceholder: 'Write an option',
+        optionsEmpty: 'No options yet.',
+        optionsRemove: 'Remove option',
+        optionsReorder: 'Reorder option',
+        errorIncomplete: 'Give the field a text and pick its type.',
+        errorOptionsRequired: 'This field type needs at least one option.',
+        typeTEXT: 'Short text',
+        typeTEXTAREA: 'Long text',
+        typeEMAIL: 'Email',
+        typePHONE: 'Phone',
+        typeNUMBER: 'Number',
+        typeDATE: 'Date',
+        typeSELECT: 'Dropdown',
+        typeRADIO: 'Single choice',
+        typeMULTI_SELECT: 'Multiple choice',
+        typeCHECK: 'Checkbox',
+        typeTOGGLE: 'Yes or no',
+        typeCURRENCY: 'Amount',
+        typeATTACHMENT: 'Attachment',
+        typeFILE: 'File',
+        typeEMOJI_RATING: 'Emoji rating',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQtc2NoZW1hLWVkaXRvci5pMThuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb21wb25lbnRzL29yZ2FuaXNtcy9maWVsZC1zY2hlbWEtZWRpdG9yL2ZpZWxkLXNjaGVtYS1lZGl0b3IuaTE4bi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBcUI7SUFDeEQsRUFBRSxFQUFFO1FBQ0YsWUFBWSxFQUFFLGVBQWU7UUFDN0IsVUFBVSxFQUFFLGlCQUFpQjtRQUM3QixnQkFBZ0IsRUFBRSxvQ0FBb0M7UUFDdEQsU0FBUyxFQUFFLGVBQWU7UUFDMUIsZ0JBQWdCLEVBQUUsaUNBQWlDO1FBQ25ELFNBQVMsRUFBRSxvQkFBb0I7UUFDL0IsYUFBYSxFQUFFLGFBQWE7UUFDNUIsWUFBWSxFQUFFLFVBQVU7UUFDeEIsV0FBVyxFQUFFLDZEQUE2RDtRQUMxRSxVQUFVLEVBQUUsZ0JBQWdCO1FBQzVCLFdBQVcsRUFBRSxVQUFVO1FBQ3ZCLGtCQUFrQixFQUFFLG9CQUFvQjtRQUN4QyxZQUFZLEVBQUUsMEJBQTBCO1FBQ3hDLGFBQWEsRUFBRSxlQUFlO1FBQzlCLGNBQWMsRUFBRSxrQkFBa0I7UUFDbEMsZUFBZSxFQUFFLDBDQUEwQztRQUMzRCxvQkFBb0IsRUFBRSxrREFBa0Q7UUFDeEUsUUFBUSxFQUFFLGFBQWE7UUFDdkIsWUFBWSxFQUFFLGFBQWE7UUFDM0IsU0FBUyxFQUFFLFFBQVE7UUFDbkIsU0FBUyxFQUFFLFVBQVU7UUFDckIsVUFBVSxFQUFFLFFBQVE7UUFDcEIsUUFBUSxFQUFFLE9BQU87UUFDakIsVUFBVSxFQUFFLG1CQUFtQjtRQUMvQixTQUFTLEVBQUUsaUJBQWlCO1FBQzVCLGdCQUFnQixFQUFFLGlCQUFpQjtRQUNuQyxTQUFTLEVBQUUsU0FBUztRQUNwQixVQUFVLEVBQUUsU0FBUztRQUNyQixZQUFZLEVBQUUsT0FBTztRQUNyQixjQUFjLEVBQUUsaUJBQWlCO1FBQ2pDLFFBQVEsRUFBRSxTQUFTO1FBQ25CLGdCQUFnQixFQUFFLHdCQUF3QjtLQUMzQztJQUNELEVBQUUsRUFBRTtRQUNGLFlBQVksRUFBRSxZQUFZO1FBQzFCLFVBQVUsRUFBRSxZQUFZO1FBQ3hCLGdCQUFnQixFQUFFLGdDQUFnQztRQUNsRCxTQUFTLEVBQUUsWUFBWTtRQUN2QixnQkFBZ0IsRUFBRSw4QkFBOEI7UUFDaEQsU0FBUyxFQUFFLHNCQUFzQjtRQUNqQyxhQUFhLEVBQUUsVUFBVTtRQUN6QixZQUFZLEVBQUUsU0FBUztRQUN2QixXQUFXLEVBQUUsNENBQTRDO1FBQ3pELFVBQVUsRUFBRSxZQUFZO1FBQ3hCLFdBQVcsRUFBRSxTQUFTO1FBQ3RCLGtCQUFrQixFQUFFLGlCQUFpQjtRQUNyQyxZQUFZLEVBQUUsaUJBQWlCO1FBQy9CLGFBQWEsRUFBRSxlQUFlO1FBQzlCLGNBQWMsRUFBRSxnQkFBZ0I7UUFDaEMsZUFBZSxFQUFFLDBDQUEwQztRQUMzRCxvQkFBb0IsRUFBRSw0Q0FBNEM7UUFDbEUsUUFBUSxFQUFFLFlBQVk7UUFDdEIsWUFBWSxFQUFFLFdBQVc7UUFDekIsU0FBUyxFQUFFLE9BQU87UUFDbEIsU0FBUyxFQUFFLE9BQU87UUFDbEIsVUFBVSxFQUFFLFFBQVE7UUFDcEIsUUFBUSxFQUFFLE1BQU07UUFDaEIsVUFBVSxFQUFFLFVBQVU7UUFDdEIsU0FBUyxFQUFFLGVBQWU7UUFDMUIsZ0JBQWdCLEVBQUUsaUJBQWlCO1FBQ25DLFNBQVMsRUFBRSxVQUFVO1FBQ3JCLFVBQVUsRUFBRSxXQUFXO1FBQ3ZCLFlBQVksRUFBRSxRQUFRO1FBQ3RCLGNBQWMsRUFBRSxZQUFZO1FBQzVCLFFBQVEsRUFBRSxNQUFNO1FBQ2hCLGdCQUFnQixFQUFFLGNBQWM7S0FDakM7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTGFuZ3VhZ2VzQ29udGVudCB9IGZyb20gJy4uLy4uLy4uL3NlcnZpY2VzL2kxOG4nO1xuXG5leHBvcnQgY29uc3QgRklFTERfU0NIRU1BX0VESVRPUl9JMThOOiBMYW5ndWFnZXNDb250ZW50ID0ge1xuICBlczoge1xuICAgIHByZXNldHNUaXRsZTogJ0VtcGllemEgZGVzZGUnLFxuICAgIGxhYmVsTGFiZWw6ICdUZXh0byBkZWwgY2FtcG8nLFxuICAgIGxhYmVsUGxhY2Vob2xkZXI6ICdFc2NyaWJlIGxvIHF1ZSB2ZXLDoSBxdWllbiByZXNwb25kZScsXG4gICAgdHlwZUxhYmVsOiAnVGlwbyBkZSBjYW1wbycsXG4gICAgcGxhY2Vob2xkZXJMYWJlbDogJ1RleHRvIGRlIGF5dWRhIGRlbnRybyBkZWwgY2FtcG8nLFxuICAgIGhpbnRMYWJlbDogJ05vdGEgYmFqbyBlbCBjYW1wbycsXG4gICAgcmVxdWlyZWRMYWJlbDogJ09ibGlnYXRvcmlvJyxcbiAgICBvcHRpb25zVGl0bGU6ICdPcGNpb25lcycsXG4gICAgb3B0aW9uc0hpbnQ6ICdFc3RhcyBzb24gbGFzIGFsdGVybmF0aXZhcyBxdWUgcHVlZGUgZWxlZ2lyIHF1aWVuIHJlc3BvbmRlLicsXG4gICAgb3B0aW9uc0FkZDogJ0FncmVnYXIgb3BjacOzbicsXG4gICAgb3B0aW9uc0xpc3Q6ICdPcGNpb25lcycsXG4gICAgb3B0aW9uc1BsYWNlaG9sZGVyOiAnRXNjcmliZSB1bmEgb3BjacOzbicsXG4gICAgb3B0aW9uc0VtcHR5OiAnVG9kYXbDrWEgbm8gaGF5IG9wY2lvbmVzLicsXG4gICAgb3B0aW9uc1JlbW92ZTogJ1F1aXRhciBvcGNpw7NuJyxcbiAgICBvcHRpb25zUmVvcmRlcjogJ1Jlb3JkZW5hciBvcGNpw7NuJyxcbiAgICBlcnJvckluY29tcGxldGU6ICdQb25sZSB1biB0ZXh0byBhbCBjYW1wbyB5IGVsaWdlIHN1IHRpcG8uJyxcbiAgICBlcnJvck9wdGlvbnNSZXF1aXJlZDogJ0VzdGUgdGlwbyBkZSBjYW1wbyBuZWNlc2l0YSBhbCBtZW5vcyB1bmEgb3BjacOzbi4nLFxuICAgIHR5cGVURVhUOiAnVGV4dG8gY29ydG8nLFxuICAgIHR5cGVURVhUQVJFQTogJ1RleHRvIGxhcmdvJyxcbiAgICB0eXBlRU1BSUw6ICdDb3JyZW8nLFxuICAgIHR5cGVQSE9ORTogJ1RlbMOpZm9ubycsXG4gICAgdHlwZU5VTUJFUjogJ07Dum1lcm8nLFxuICAgIHR5cGVEQVRFOiAnRmVjaGEnLFxuICAgIHR5cGVTRUxFQ1Q6ICdMaXN0YSBkZXNwbGVnYWJsZScsXG4gICAgdHlwZVJBRElPOiAnVW5hIHNvbGEgb3BjacOzbicsXG4gICAgdHlwZU1VTFRJX1NFTEVDVDogJ1ZhcmlhcyBvcGNpb25lcycsXG4gICAgdHlwZUNIRUNLOiAnQ2FzaWxsYScsXG4gICAgdHlwZVRPR0dMRTogJ1PDrSBvIG5vJyxcbiAgICB0eXBlQ1VSUkVOQ1k6ICdNb250bycsXG4gICAgdHlwZUFUVEFDSE1FTlQ6ICdBcmNoaXZvIGFkanVudG8nLFxuICAgIHR5cGVGSUxFOiAnQXJjaGl2bycsXG4gICAgdHlwZUVNT0pJX1JBVElORzogJ0NhbGlmaWNhY2nDs24gY29uIGVtb2ppJyxcbiAgfSxcbiAgZW46IHtcbiAgICBwcmVzZXRzVGl0bGU6ICdTdGFydCBmcm9tJyxcbiAgICBsYWJlbExhYmVsOiAnRmllbGQgdGV4dCcsXG4gICAgbGFiZWxQbGFjZWhvbGRlcjogJ1dyaXRlIHdoYXQgdGhlIHBlcnNvbiB3aWxsIHNlZScsXG4gICAgdHlwZUxhYmVsOiAnRmllbGQgdHlwZScsXG4gICAgcGxhY2Vob2xkZXJMYWJlbDogJ0hlbHBlciB0ZXh0IGluc2lkZSB0aGUgZmllbGQnLFxuICAgIGhpbnRMYWJlbDogJ05vdGUgYmVsb3cgdGhlIGZpZWxkJyxcbiAgICByZXF1aXJlZExhYmVsOiAnUmVxdWlyZWQnLFxuICAgIG9wdGlvbnNUaXRsZTogJ09wdGlvbnMnLFxuICAgIG9wdGlvbnNIaW50OiAnVGhlc2UgYXJlIHRoZSBjaG9pY2VzIHRoZSBwZXJzb24gY2FuIHBpY2suJyxcbiAgICBvcHRpb25zQWRkOiAnQWRkIG9wdGlvbicsXG4gICAgb3B0aW9uc0xpc3Q6ICdPcHRpb25zJyxcbiAgICBvcHRpb25zUGxhY2Vob2xkZXI6ICdXcml0ZSBhbiBvcHRpb24nLFxuICAgIG9wdGlvbnNFbXB0eTogJ05vIG9wdGlvbnMgeWV0LicsXG4gICAgb3B0aW9uc1JlbW92ZTogJ1JlbW92ZSBvcHRpb24nLFxuICAgIG9wdGlvbnNSZW9yZGVyOiAnUmVvcmRlciBvcHRpb24nLFxuICAgIGVycm9ySW5jb21wbGV0ZTogJ0dpdmUgdGhlIGZpZWxkIGEgdGV4dCBhbmQgcGljayBpdHMgdHlwZS4nLFxuICAgIGVycm9yT3B0aW9uc1JlcXVpcmVkOiAnVGhpcyBmaWVsZCB0eXBlIG5lZWRzIGF0IGxlYXN0IG9uZSBvcHRpb24uJyxcbiAgICB0eXBlVEVYVDogJ1Nob3J0IHRleHQnLFxuICAgIHR5cGVURVhUQVJFQTogJ0xvbmcgdGV4dCcsXG4gICAgdHlwZUVNQUlMOiAnRW1haWwnLFxuICAgIHR5cGVQSE9ORTogJ1Bob25lJyxcbiAgICB0eXBlTlVNQkVSOiAnTnVtYmVyJyxcbiAgICB0eXBlREFURTogJ0RhdGUnLFxuICAgIHR5cGVTRUxFQ1Q6ICdEcm9wZG93bicsXG4gICAgdHlwZVJBRElPOiAnU2luZ2xlIGNob2ljZScsXG4gICAgdHlwZU1VTFRJX1NFTEVDVDogJ011bHRpcGxlIGNob2ljZScsXG4gICAgdHlwZUNIRUNLOiAnQ2hlY2tib3gnLFxuICAgIHR5cGVUT0dHTEU6ICdZZXMgb3Igbm8nLFxuICAgIHR5cGVDVVJSRU5DWTogJ0Ftb3VudCcsXG4gICAgdHlwZUFUVEFDSE1FTlQ6ICdBdHRhY2htZW50JyxcbiAgICB0eXBlRklMRTogJ0ZpbGUnLFxuICAgIHR5cGVFTU9KSV9SQVRJTkc6ICdFbW9qaSByYXRpbmcnLFxuICB9LFxufTtcbiJdfQ==

package/esm2022/lib/components/organisms/field-schema-editor/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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