@vsn-ux/ngx-gaia 1.0.0-alpha.1

package/fesm2022/vsn-ux-ngx-gaia.mjs

@@ -0,0 +1,979 @@
+import * as i0 from '@angular/core';
+import { input, Component, ChangeDetectionStrategy, ViewEncapsulation, NgModule, forwardRef, inject, Injector, signal, booleanAttribute, linkedSignal, output, computed, Attribute, Directive, model, HostListener, contentChild, InjectionToken, effect, TemplateRef, ElementRef, NgZone, numberAttribute, Input } from '@angular/core';
+import * as i1 from 'lucide-angular';
+import { LucideAngularModule } from 'lucide-angular';
+import { NG_VALUE_ACCESSOR, NgControl, NG_VALIDATORS, CheckboxRequiredValidator } from '@angular/forms';
+import * as i1$1 from '@angular/cdk/menu';
+import { CdkMenu, CdkMenuItem, CdkMenuTrigger } from '@angular/cdk/menu';
+import { Overlay } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Subject, takeUntil, map } from 'rxjs';
+import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
+import { NgTemplateOutlet } from '@angular/common';
+
+class GaButtonDirective {
+    variant = input.required({
+        alias: 'gaButton',
+    });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.0.1", type: GaButtonDirective, isStandalone: true, selector: "button[gaButton], a[gaButton]", inputs: { variant: { classPropertyName: "variant", publicName: "gaButton", isSignal: true, isRequired: true, transformFunction: null } }, host: { properties: { "class.ga-button--secondary": "!variant() || variant() === 'secondary'", "class.ga-button--primary": "variant() === 'primary'", "class.ga-button--ghost": "variant() === 'ghost'", "class.ga-button--transparent": "variant() === 'transparent'" }, classAttribute: "ga-button" }, ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaButtonDirective, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'button[gaButton], a[gaButton]',
+                    host: {
+                        class: 'ga-button',
+                        '[class.ga-button--secondary]': `!variant() || variant() === 'secondary'`,
+                        '[class.ga-button--primary]': `variant() === 'primary'`,
+                        '[class.ga-button--ghost]': `variant() === 'ghost'`,
+                        '[class.ga-button--transparent]': `variant() === 'transparent'`,
+                    },
+                    template: `<ng-content />`,
+                }]
+        }] });
+
+class GaIconButtonDirective {
+    icon = input.required({ alias: 'gaIconButton' });
+    variant = input('secondary', {
+        alias: 'gaIconButtonVariant',
+    });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaIconButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.0.1", type: GaIconButtonDirective, isStandalone: true, selector: "button[gaIconButton], a[gaIconButton]", inputs: { icon: { classPropertyName: "icon", publicName: "gaIconButton", isSignal: true, isRequired: true, transformFunction: null }, variant: { classPropertyName: "variant", publicName: "gaIconButtonVariant", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.ga-button--primary": "variant() === 'primary'", "class.ga-button--secondary": "variant() === 'secondary'", "class.ga-button--ghost": "variant() === 'ghost'" }, classAttribute: "ga-button ga-button--icon-only" }, ngImport: i0, template: `
+    <lucide-angular [img]="icon()" />
+    <span class="ga-button__icon-label"><ng-content /></span>
+  `, isInline: true, styles: [".ga-button__icon-label{position:absolute!important;width:1px!important;height:1px!important;padding:0!important;margin:-1px!important;overflow:hidden!important;clip:rect(0,0,0,0)!important;-webkit-clip-path:inset(50%)!important;clip-path:inset(50%)!important;white-space:nowrap!important;border-width:0!important}\n"], dependencies: [{ kind: "ngmodule", type: LucideAngularModule }, { kind: "component", type: i1.LucideAngularComponent, selector: "lucide-angular, lucide-icon, i-lucide, span-lucide", inputs: ["class", "name", "img", "color", "absoluteStrokeWidth", "size", "strokeWidth"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaIconButtonDirective, decorators: [{
+            type: Component,
+            args: [{ selector: 'button[gaIconButton], a[gaIconButton]', imports: [LucideAngularModule], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: `
+    <lucide-angular [img]="icon()" />
+    <span class="ga-button__icon-label"><ng-content /></span>
+  `, host: {
+                        class: 'ga-button ga-button--icon-only',
+                        '[class.ga-button--primary]': `variant() === 'primary'`,
+                        '[class.ga-button--secondary]': `variant() === 'secondary'`,
+                        '[class.ga-button--ghost]': `variant() === 'ghost'`,
+                    }, styles: [".ga-button__icon-label{position:absolute!important;width:1px!important;height:1px!important;padding:0!important;margin:-1px!important;overflow:hidden!important;clip:rect(0,0,0,0)!important;-webkit-clip-path:inset(50%)!important;clip-path:inset(50%)!important;white-space:nowrap!important;border-width:0!important}\n"] }]
+        }] });
+
+class GaButtonModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaButtonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.1", ngImport: i0, type: GaButtonModule, imports: [GaButtonDirective, GaIconButtonDirective], exports: [GaButtonDirective, GaIconButtonDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaButtonModule, imports: [GaIconButtonDirective] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaButtonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [GaButtonDirective, GaIconButtonDirective],
+                    exports: [GaButtonDirective, GaIconButtonDirective],
+                }]
+        }] });
+
+const CHECKBOX_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => GaCheckboxComponent),
+    multi: true,
+};
+// Increasing integer for generating unique ids for checkbox components.
+// Inspired by @angular/components
+let nextUniqueId$2 = 0;
+class GaCheckboxComponent {
+    tabindex;
+    /** @ignore */
+    _uniqueId = `ga-checkbox-${++nextUniqueId$2}`;
+    /** @ignore */
+    injector = inject(Injector);
+    /** @ignore */
+    _onTouched;
+    /** @ignore */
+    _onModelChanged;
+    /** @ignore */
+    _invalidNgModel = signal(false);
+    _ngModelName = signal(null);
+    /** The value attribute of the native input element */
+    value = input(null);
+    disabled = input(false, {
+        transform: booleanAttribute,
+    });
+    checked = input(false, {
+        transform: booleanAttribute,
+    });
+    nameInput = input(null, { alias: 'name' });
+    id = input(null);
+    indeterminate = input(false, { transform: booleanAttribute });
+    ariaLabel = input(null, { alias: 'aria-label' });
+    ariaLabelledby = input(null, {
+        alias: 'aria-labelledby',
+    });
+    ariaDescribedby = input(null, {
+        alias: 'aria-describedby',
+    });
+    ariaInvalid = input(null, { alias: 'aria-invalid' });
+    ariaErrormessage = input(null, {
+        alias: 'aria-errormessage',
+    });
+    required = input(false, { transform: booleanAttribute });
+    disabledModel = linkedSignal(() => this.disabled());
+    checkedModel = linkedSignal(() => this.checked());
+    change = output();
+    indeterminateChange = output();
+    /** @ignore */
+    inputId = computed(() => (this.id() ? this.id() : this._uniqueId));
+    /** @ignore */
+    name = computed(() => {
+        return this.nameInput() ?? this._ngModelName() ?? this._uniqueId;
+    });
+    /** @ignore */
+    invalid = computed(() => {
+        return this.ariaInvalid()
+            ? this.ariaInvalid() === 'true'
+            : this._invalidNgModel();
+    });
+    constructor(
+    /** @ignore */
+    tabindex) {
+        this.tabindex = tabindex;
+    }
+    ngDoCheck() {
+        const ngControl = this.injector.get(NgControl, null);
+        if (ngControl) {
+            this._invalidNgModel.set(!!ngControl.invalid);
+            this._ngModelName.set(ngControl.name);
+        }
+    }
+    /** @ignore */
+    onInputChange(event) {
+        // We always have to stop propagation on the change event.
+        // Otherwise the change event, from the input element, will bubble up and
+        // emit its event object to the `change` output.
+        event.stopPropagation();
+        if (this.disabled()) {
+            return;
+        }
+        this.checkedModel.set(!this.checkedModel());
+        this.updateModel();
+    }
+    /** @ignore */
+    onBlur() {
+        this._onTouched?.();
+    }
+    /** @ignore */
+    registerOnChange(fn) {
+        this._onModelChanged = fn;
+    }
+    /** @ignore */
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    /** @ignore */
+    writeValue(value) {
+        this.checkedModel.set(!!value);
+    }
+    /** @ignore */
+    setDisabledState(isDisabled) {
+        this.disabledModel.set(isDisabled);
+    }
+    /** @ignore */
+    updateModel() {
+        this._onModelChanged?.(this.checkedModel());
+        this.change.emit(this.checkedModel());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxComponent, deps: [{ token: 'tabindex', attribute: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.0.1", type: GaCheckboxComponent, isStandalone: true, selector: "ga-checkbox", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, checked: { classPropertyName: "checked", publicName: "checked", isSignal: true, isRequired: false, transformFunction: null }, nameInput: { classPropertyName: "nameInput", publicName: "name", isSignal: true, isRequired: false, transformFunction: null }, id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, indeterminate: { classPropertyName: "indeterminate", publicName: "indeterminate", isSignal: true, isRequired: false, transformFunction: null }, ariaLabel: { classPropertyName: "ariaLabel", publicName: "aria-label", isSignal: true, isRequired: false, transformFunction: null }, ariaLabelledby: { classPropertyName: "ariaLabelledby", publicName: "aria-labelledby", isSignal: true, isRequired: false, transformFunction: null }, ariaDescribedby: { classPropertyName: "ariaDescribedby", publicName: "aria-describedby", isSignal: true, isRequired: false, transformFunction: null }, ariaInvalid: { classPropertyName: "ariaInvalid", publicName: "aria-invalid", isSignal: true, isRequired: false, transformFunction: null }, ariaErrormessage: { classPropertyName: "ariaErrormessage", publicName: "aria-errormessage", isSignal: true, isRequired: false, transformFunction: null }, required: { classPropertyName: "required", publicName: "required", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { change: "change", indeterminateChange: "indeterminateChange" }, host: { properties: { "class.ga-checkbox--invalid": "invalid()", "attr.id": "null", "attr.tabindex": "null", "attr.aria-label": "null", "attr.aria-labelledby": "null", "attr.aria-describedby": "null", "attr.aria-invalid": "null", "attr.aria-errormessage": "null" }, classAttribute: "ga-checkbox" }, providers: [CHECKBOX_CONTROL_VALUE_ACCESSOR], ngImport: i0, template: "<input\n  type=\"checkbox\"\n  class=\"ga-checkbox__native\"\n  [attr.id]=\"inputId()\"\n  [name]=\"name()\"\n  [checked]=\"checkedModel()\"\n  [indeterminate]=\"indeterminate()\"\n  [disabled]=\"disabledModel()\"\n  [required]=\"required()\"\n  [attr.value]=\"value()\"\n  [attr.tabindex]=\"tabindex\"\n  [attr.aria-label]=\"ariaLabel()\"\n  [attr.aria-labelledby]=\"ariaLabelledby()\"\n  [attr.aria-describedby]=\"ariaDescribedby()\"\n  [attr.aria-invalid]=\"ariaInvalid()\"\n  [attr.aria-errormessage]=\"ariaErrormessage()\"\n  (change)=\"onInputChange($event)\"\n  (blur)=\"onBlur()\"\n/>\n<div class=\"ga-checkbox__marker\">\n  <svg\n    class=\"ga-checkbox__marker__indicator-checked\"\n    viewBox=\"0 0 16 16\"\n    fill=\"none\"\n  >\n    <path\n      d=\"M4 9L6 11L12 5\"\n      stroke=\"currentColor\"\n      stroke-width=\"2\"\n      stroke-linecap=\"round\"\n      stroke-linejoin=\"round\"\n    />\n  </svg>\n  <svg\n    class=\"ga-checkbox__marker__indicator-indeterminate\"\n    viewBox=\"0 0 16 16\"\n    fill=\"none\"\n  >\n    <path\n      d=\"M4 8H6.13333H12\"\n      stroke=\"currentColor\"\n      stroke-width=\"2\"\n      stroke-linecap=\"round\"\n      stroke-linejoin=\"round\"\n    />\n  </svg>\n</div>\n\n<label class=\"ga-checkbox__label\" [attr.for]=\"inputId()\"\n  ><ng-content></ng-content\n></label>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ga-checkbox', changeDetection: ChangeDetectionStrategy.OnPush, providers: [CHECKBOX_CONTROL_VALUE_ACCESSOR], host: {
+                        class: 'ga-checkbox',
+                        '[class.ga-checkbox--invalid]': 'invalid()',
+                        '[attr.id]': 'null',
+                        '[attr.tabindex]': 'null',
+                        '[attr.aria-label]': 'null',
+                        '[attr.aria-labelledby]': 'null',
+                        '[attr.aria-describedby]': 'null',
+                        '[attr.aria-invalid]': 'null',
+                        '[attr.aria-errormessage]': 'null',
+                    }, template: "<input\n  type=\"checkbox\"\n  class=\"ga-checkbox__native\"\n  [attr.id]=\"inputId()\"\n  [name]=\"name()\"\n  [checked]=\"checkedModel()\"\n  [indeterminate]=\"indeterminate()\"\n  [disabled]=\"disabledModel()\"\n  [required]=\"required()\"\n  [attr.value]=\"value()\"\n  [attr.tabindex]=\"tabindex\"\n  [attr.aria-label]=\"ariaLabel()\"\n  [attr.aria-labelledby]=\"ariaLabelledby()\"\n  [attr.aria-describedby]=\"ariaDescribedby()\"\n  [attr.aria-invalid]=\"ariaInvalid()\"\n  [attr.aria-errormessage]=\"ariaErrormessage()\"\n  (change)=\"onInputChange($event)\"\n  (blur)=\"onBlur()\"\n/>\n<div class=\"ga-checkbox__marker\">\n  <svg\n    class=\"ga-checkbox__marker__indicator-checked\"\n    viewBox=\"0 0 16 16\"\n    fill=\"none\"\n  >\n    <path\n      d=\"M4 9L6 11L12 5\"\n      stroke=\"currentColor\"\n      stroke-width=\"2\"\n      stroke-linecap=\"round\"\n      stroke-linejoin=\"round\"\n    />\n  </svg>\n  <svg\n    class=\"ga-checkbox__marker__indicator-indeterminate\"\n    viewBox=\"0 0 16 16\"\n    fill=\"none\"\n  >\n    <path\n      d=\"M4 8H6.13333H12\"\n      stroke=\"currentColor\"\n      stroke-width=\"2\"\n      stroke-linecap=\"round\"\n      stroke-linejoin=\"round\"\n    />\n  </svg>\n</div>\n\n<label class=\"ga-checkbox__label\" [attr.for]=\"inputId()\"\n  ><ng-content></ng-content\n></label>\n" }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['tabindex']
+                }] }] });
+
+const GA_CHECKBOX_REQUIRED_VALIDATOR = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => GaCheckboxRequiredValidator),
+    multi: true,
+};
+/**
+ * Validator for Gaia checkbox's required attribute in template-driven checkbox.
+ * Current CheckboxRequiredValidator only work with `input type=checkbox` and does not
+ * work with `ga-checkbox`.
+ */
+class GaCheckboxRequiredValidator extends CheckboxRequiredValidator {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxRequiredValidator, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.1", type: GaCheckboxRequiredValidator, isStandalone: true, selector: "ga-checkbox[required][formControlName], ga-checkbox[required][formControl], ga-checkbox[required][ngModel]", providers: [GA_CHECKBOX_REQUIRED_VALIDATOR], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxRequiredValidator, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `ga-checkbox[required][formControlName], ga-checkbox[required][formControl], ga-checkbox[required][ngModel]`,
+                    providers: [GA_CHECKBOX_REQUIRED_VALIDATOR],
+                }]
+        }] });
+
+class GaCheckboxModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxModule, imports: [GaCheckboxComponent, GaCheckboxRequiredValidator], exports: [GaCheckboxComponent, GaCheckboxRequiredValidator] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaCheckboxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [GaCheckboxComponent, GaCheckboxRequiredValidator],
+                    exports: [GaCheckboxComponent, GaCheckboxRequiredValidator],
+                }]
+        }] });
+
+class GaSegmentedControlComponent {
+    selected = model();
+    change = output();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.0.1", type: GaSegmentedControlComponent, isStandalone: true, selector: "ga-segmented-control", inputs: { selected: { classPropertyName: "selected", publicName: "selected", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { selected: "selectedChange", change: "change" }, host: { attributes: { "role": "group" }, classAttribute: "ga-segmented-control" }, ngImport: i0, template: "<ng-content select=\"button[gaSegmentedControlButton]\"></ng-content>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ga-segmented-control', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        role: 'group',
+                        class: 'ga-segmented-control',
+                    }, template: "<ng-content select=\"button[gaSegmentedControlButton]\"></ng-content>\n" }]
+        }] });
+
+class GaSegmentedControlButtonDirective {
+    /** @ignore */
+    group = inject(GaSegmentedControlComponent, { host: true });
+    value = input();
+    selected = computed(() => {
+        return (this.value() !== undefined &&
+            this.group.selected() !== undefined &&
+            this.group.selected() === this.value());
+    });
+    onClick() {
+        this.group.selected.set(this.value());
+        this.group.change.emit(this.value());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.0.1", type: GaSegmentedControlButtonDirective, isStandalone: true, selector: "[gaSegmentedControlButton]", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button" }, listeners: { "click": "onClick()" }, properties: { "class.ga-segmented-control__button--selected": "selected()", "attr.aria-pressed": "selected()" }, classAttribute: "ga-segmented-control__button" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlButtonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gaSegmentedControlButton]',
+                    host: {
+                        type: 'button',
+                        class: 'ga-segmented-control__button',
+                        '[class.ga-segmented-control__button--selected]': 'selected()',
+                        '[attr.aria-pressed]': 'selected()',
+                    },
+                }]
+        }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+
+class GaSegmentedControlModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlModule, imports: [GaSegmentedControlComponent, GaSegmentedControlButtonDirective], exports: [GaSegmentedControlComponent, GaSegmentedControlButtonDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaSegmentedControlModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [GaSegmentedControlComponent, GaSegmentedControlButtonDirective],
+                    exports: [GaSegmentedControlComponent, GaSegmentedControlButtonDirective],
+                }]
+        }] });
+
+class GaInputComponent {
+    implicitNgControl = contentChild(NgControl);
+    implicitInvalid = signal(false);
+    invalidInput = input(null, { transform: booleanAttribute });
+    invalid = computed(() => {
+        return this.invalidInput() ?? this.implicitInvalid();
+    });
+    ngDoCheck() {
+        // we can rely on computed because `ivalid` of NgControl is not a signal, yet
+        const implicitNgControl = this.implicitNgControl();
+        if (implicitNgControl) {
+            this.implicitInvalid.set(!!implicitNgControl.invalid && !!implicitNgControl.dirty);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "19.0.1", type: GaInputComponent, isStandalone: true, selector: "ga-input", inputs: { invalidInput: { classPropertyName: "invalidInput", publicName: "invalidInput", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.ga-input--invalid": "invalid()" }, classAttribute: "ga-input" }, queries: [{ propertyName: "implicitNgControl", first: true, predicate: NgControl, descendants: true, isSignal: true }], ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaInputComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ga-input',
+                    template: `<ng-content />`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        class: 'ga-input',
+                        '[class.ga-input--invalid]': 'invalid()',
+                    },
+                }]
+        }] });
+
+const GA_FORM_CONTROL = new InjectionToken('ga-form-control');
+class GaFormControlDirective {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFormControlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.1", type: GaFormControlDirective, isStandalone: true, selector: "[gaFormControl]", providers: [
+            { provide: GA_FORM_CONTROL, useExisting: GaFormControlDirective },
+        ], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFormControlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gaFormControl]',
+                    providers: [
+                        { provide: GA_FORM_CONTROL, useExisting: GaFormControlDirective },
+                    ],
+                }]
+        }] });
+
+let nextUniqueId$1 = 0;
+class GaInputDirective {
+    uniqueId = `ga-input-${++nextUniqueId$1}`;
+    implicitNgControl = inject(NgControl, {
+        optional: true,
+        self: true,
+    });
+    hasWrapper = inject(GaInputComponent, { optional: true });
+    implicitInvalid = signal(false);
+    implicitErrors = signal(null);
+    invalidInput = input(null, { transform: booleanAttribute });
+    idInput = input(undefined, { alias: 'id' });
+    invalid = computed(() => {
+        return this.invalidInput() ?? this.implicitInvalid();
+    });
+    id = computed(() => {
+        return this.idInput() ?? this.uniqueId;
+    });
+    errors = this.implicitErrors.asReadonly();
+    ngDoCheck() {
+        if (this.hasWrapper)
+            return;
+        // we can rely on computed because `ivalid` of NgControl is not a signal, yet
+        const implicitNgControl = this.implicitNgControl;
+        if (implicitNgControl) {
+            this.implicitInvalid.set(!!implicitNgControl.invalid && !!implicitNgControl.dirty);
+            this.implicitErrors.set(implicitNgControl.errors);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaInputDirective, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.0.1", type: GaInputDirective, isStandalone: true, selector: "[gaInput]", inputs: { invalidInput: { classPropertyName: "invalidInput", publicName: "invalidInput", isSignal: true, isRequired: false, transformFunction: null }, idInput: { classPropertyName: "idInput", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.id": "id()", "class.ga-input": "!hasWrapper", "class.ga-input--invalid": "!hasWrapper && invalid()" } }, providers: [{ provide: GA_FORM_CONTROL, useExisting: GaInputDirective }], ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaInputDirective, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[gaInput]',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[attr.id]': 'id()',
+                        '[class.ga-input]': '!hasWrapper',
+                        '[class.ga-input--invalid]': '!hasWrapper && invalid()',
+                    },
+                    providers: [{ provide: GA_FORM_CONTROL, useExisting: GaInputDirective }],
+                }]
+        }] });
+
+class GaInputModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.1", ngImport: i0, type: GaInputModule, imports: [GaInputComponent, GaInputDirective], exports: [GaInputComponent, GaInputDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaInputModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaInputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [GaInputComponent, GaInputDirective],
+                    exports: [GaInputComponent, GaInputDirective],
+                }]
+        }] });
+
+let nextUniqueId = 0;
+class GaFormFieldComponent {
+    uniqueId = `ga-form-field-${++nextUniqueId}`;
+    formControl = contentChild(GA_FORM_CONTROL);
+    controlId = computed(() => {
+        return this.formControl()?.id() ?? this.uniqueId;
+    });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFormFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "19.0.1", type: GaFormFieldComponent, isStandalone: true, selector: "ga-form-field", host: { classAttribute: "ga-form-field" }, queries: [{ propertyName: "formControl", first: true, predicate: GA_FORM_CONTROL, descendants: true, isSignal: true }], exportAs: ["gaFormField"], ngImport: i0, template: "<ng-content />\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFormFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ga-form-field', exportAs: 'gaFormField', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'ga-form-field',
+                    }, template: "<ng-content />\n" }]
+        }] });
+
+class GaFieldLabelComponent {
+    formField = inject(GaFormFieldComponent);
+    for = input();
+    controlId = computed(() => {
+        return this.for() ?? this.formField.controlId();
+    });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFieldLabelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.0.1", type: GaFieldLabelComponent, isStandalone: true, selector: "ga-label", inputs: { for: { classPropertyName: "for", publicName: "for", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `<label [attr.for]="controlId()" class="ga-form-field__label"
+    ><ng-content
+  /></label>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFieldLabelComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ga-label',
+                    template: `<label [attr.for]="controlId()" class="ga-form-field__label"
+    ><ng-content
+  /></label>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+
+class GaFieldInfoComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFieldInfoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.1", type: GaFieldInfoComponent, isStandalone: true, selector: "ga-info", host: { classAttribute: "ga-form-field__info" }, ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFieldInfoComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ga-info',
+                    template: `<ng-content />`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        class: 'ga-form-field__info',
+                    },
+                }]
+        }] });
+
+class GaFormFieldModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFormFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.1", ngImport: i0, type: GaFormFieldModule, imports: [GaFormFieldComponent,
+            GaFieldLabelComponent,
+            GaFieldInfoComponent,
+            GaFormControlDirective], exports: [GaFormFieldComponent,
+            GaFieldLabelComponent,
+            GaFieldInfoComponent,
+            GaFormControlDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFormFieldModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaFormFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        GaFormFieldComponent,
+                        GaFieldLabelComponent,
+                        GaFieldInfoComponent,
+                        GaFormControlDirective,
+                    ],
+                    exports: [
+                        GaFormFieldComponent,
+                        GaFieldLabelComponent,
+                        GaFieldInfoComponent,
+                        GaFormControlDirective,
+                    ],
+                }]
+        }] });
+
+class GaMenuComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.1", type: GaMenuComponent, isStandalone: true, selector: "ga-menu", host: { classAttribute: "ga-menu" }, hostDirectives: [{ directive: i1$1.CdkMenu }], ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ga-menu',
+                    template: `<ng-content />`,
+                    hostDirectives: [CdkMenu],
+                    host: {
+                        class: 'ga-menu',
+                    },
+                }]
+        }] });
+
+class GaMenuItemComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.1", type: GaMenuItemComponent, isStandalone: true, selector: "[gaMenuItem]", host: { classAttribute: "ga-menu__item" }, hostDirectives: [{ directive: i1$1.CdkMenuItem }], ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[gaMenuItem]',
+                    template: `<ng-content />`,
+                    hostDirectives: [CdkMenuItem],
+                    host: {
+                        class: 'ga-menu__item',
+                    },
+                }]
+        }] });
+
+class GaMenuTriggerDirective {
+    cdkMenuTrigger = inject(CdkMenuTrigger);
+    menuRef = input.required({
+        alias: 'gaMenuTrigger',
+    });
+    constructor() {
+        effect(() => {
+            this.cdkMenuTrigger.menuTemplateRef = this.menuRef();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.0.1", type: GaMenuTriggerDirective, isStandalone: true, selector: "[gaMenuTrigger]", inputs: { menuRef: { classPropertyName: "menuRef", publicName: "gaMenuTrigger", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: i1$1.CdkMenuTrigger }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gaMenuTrigger]',
+                    standalone: true,
+                    hostDirectives: [CdkMenuTrigger],
+                }]
+        }], ctorParameters: () => [] });
+
+class GaMenuSeparatorComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuSeparatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.1", type: GaMenuSeparatorComponent, isStandalone: true, selector: "ga-menu-separator", host: { classAttribute: "ga-menu__separator" }, ngImport: i0, template: `<ng-content />`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuSeparatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ga-menu-separator',
+                    template: `<ng-content />`,
+                    host: {
+                        class: 'ga-menu__separator',
+                    },
+                }]
+        }] });
+
+class GaMenuModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.1", ngImport: i0, type: GaMenuModule, imports: [GaMenuComponent,
+            GaMenuItemComponent,
+            GaMenuTriggerDirective,
+            GaMenuSeparatorComponent], exports: [GaMenuComponent,
+            GaMenuItemComponent,
+            GaMenuTriggerDirective,
+            GaMenuSeparatorComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaMenuModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        GaMenuComponent,
+                        GaMenuItemComponent,
+                        GaMenuTriggerDirective,
+                        GaMenuSeparatorComponent,
+                    ],
+                    exports: [
+                        GaMenuComponent,
+                        GaMenuItemComponent,
+                        GaMenuTriggerDirective,
+                        GaMenuSeparatorComponent,
+                    ],
+                }]
+        }] });
+
+class GaTooltipComponent {
+    mouseLeaveSubject = new Subject();
+    afterMouseLeave = () => this.mouseLeaveSubject.asObservable();
+    mouseOver = signal(false);
+    content = input.required();
+    template = computed(() => {
+        const content = this.content();
+        return content instanceof TemplateRef ? content : null;
+    });
+    text = computed(() => {
+        const content = this.content();
+        return typeof content === 'string' ? content : null;
+    });
+    position = input();
+    offset = input(0);
+    hideTriggered = output();
+    triggerHide = () => this.hideTriggered.emit();
+    inlineStyle = computed(() => {
+        if (!this.position() || !this.offset()) {
+            return '';
+        }
+        return `--ga-tooltip-offset: ${this.offset()}px;`;
+    });
+    cssClass = computed(() => {
+        return ['ga-tooltip', `ga-tooltip--${this.position()}`].join(' ');
+    });
+    handleMouseEnter() {
+        this.mouseOver.set(true);
+    }
+    handleMouseLeave() {
+        this.mouseOver.set(false);
+        this.mouseLeaveSubject.next();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.1", type: GaTooltipComponent, isStandalone: true, selector: "ga-tooltip", inputs: { content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: true, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, offset: { classPropertyName: "offset", publicName: "offset", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { hideTriggered: "hideTriggered" }, host: { listeners: { "mouseenter": "handleMouseEnter()", "mouseleave": "handleMouseLeave()" }, properties: { "attr.style": "inlineStyle()" } }, ngImport: i0, template: "<div [class]=\"cssClass()\">\n  @if (text()) {\n    {{ text() }}\n  } @else if (template()) {\n    <ng-container\n      [ngTemplateOutlet]=\"template()\"\n      [ngTemplateOutletContext]=\"{ hide: triggerHide }\"\n    />\n  }\n</div>\n", styles: [".top-start :host,.top-center :host,.top-end :host{padding-bottom:var(--ga-tooltip-offset)}.bottom-start :host,.bottom-center :host,.bottom-end :host{padding-top:var(--ga-tooltip-offset)}.left-top :host,.left-center :host,.left-bottom :host{padding-right:var(--ga-tooltip-offset)}.right-top :host,.right-center :host,.right-bottom :host{padding-left:var(--ga-tooltip-offset)}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ga-tooltip', imports: [NgTemplateOutlet], changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        '[attr.style]': 'inlineStyle()',
+                    }, template: "<div [class]=\"cssClass()\">\n  @if (text()) {\n    {{ text() }}\n  } @else if (template()) {\n    <ng-container\n      [ngTemplateOutlet]=\"template()\"\n      [ngTemplateOutletContext]=\"{ hide: triggerHide }\"\n    />\n  }\n</div>\n", styles: [".top-start :host,.top-center :host,.top-end :host{padding-bottom:var(--ga-tooltip-offset)}.bottom-start :host,.bottom-center :host,.bottom-end :host{padding-top:var(--ga-tooltip-offset)}.left-top :host,.left-center :host,.left-bottom :host{padding-right:var(--ga-tooltip-offset)}.right-top :host,.right-center :host,.right-bottom :host{padding-left:var(--ga-tooltip-offset)}\n"] }]
+        }], propDecorators: { handleMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], handleMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+
+class GaTooltipDirective {
+    elementRef = inject(ElementRef);
+    overlay = inject(Overlay);
+    ngZone = inject(NgZone);
+    destroyed$ = new Subject();
+    _content = null;
+    tooltipInstanceDestroyed$ = null;
+    outputSubscription = null;
+    overlayRef;
+    tooltipPortal;
+    tooltipRef;
+    get tooltipInstance() {
+        return this.tooltipRef ? this.tooltipRef.instance : null;
+    }
+    currentPosition$;
+    _placement = 'right-center';
+    _offset = 15;
+    mouseOver = false;
+    _showControlMode = null;
+    _hideControlMode = null;
+    set content(value) {
+        if (value === this._content) {
+            return;
+        }
+        this._content = value;
+        // Hide tooltip with empty content
+        if (!this._content && this.overlayRef?.hasAttached()) {
+            this.hide();
+            return;
+        }
+        // Update the content in case tooltip is already opened
+        if (this.tooltipRef && this.overlayRef?.hasAttached()) {
+            this.tooltipRef.setInput('content', this._content);
+        }
+    }
+    get content() {
+        return this._content;
+    }
+    disabled = false;
+    controlMode = 'hover';
+    /**
+     * @default `gaTooltipControlMode`
+     */
+    set showControlMode(value) {
+        this._showControlMode = value;
+    }
+    get showControlMode() {
+        return this._showControlMode ?? this.controlMode;
+    }
+    /**
+     * @default `gaTooltipControlMode`
+     */
+    set hideControlMode(value) {
+        this._hideControlMode = value;
+    }
+    get hideControlMode() {
+        return this._hideControlMode ?? this.controlMode;
+    }
+    set offset(value) {
+        if (this._offset === value) {
+            return;
+        }
+        this._offset = !isNaN(value) ? value : 15;
+        this.updateTooltipPlacement();
+    }
+    get offset() {
+        return this._offset;
+    }
+    set placement(value) {
+        if (this._placement === value) {
+            return;
+        }
+        this._placement = value;
+        this.updateTooltipPlacement();
+    }
+    get placement() {
+        return this._placement;
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+        this.overlayRef?.detach();
+        this.overlayRef?.dispose();
+    }
+    show() {
+        if (this.overlayRef?.hasAttached()) {
+            return;
+        }
+        const overlayRef = this.createOverlay();
+        this.tooltipPortal =
+            this.tooltipPortal ?? new ComponentPortal(GaTooltipComponent);
+        this.tooltipInstanceDestroyed$ = new Subject();
+        this.tooltipRef = overlayRef.attach(this.tooltipPortal);
+        this.tooltipRef.setInput('content', this.content);
+        this.outputSubscription = this.tooltipInstance.hideTriggered.subscribe(() => setTimeout(() => this.hide()));
+        if (this.hideControlMode === 'hover') {
+            // Soft hide tooltip on mouse leave when control mode is set to 'hover'
+            this.tooltipInstance.afterMouseLeave()
+                .pipe(takeUntil(this.tooltipInstanceDestroyed$))
+                .subscribe(() => setTimeout(() => this.softHide()));
+        }
+        else if (this.hideControlMode === 'click') {
+            // Hide tooltip on outside click when control mode is set to 'click'
+            overlayRef
+                .outsidePointerEvents()
+                .pipe(takeUntil(this.tooltipInstanceDestroyed$))
+                .subscribe((event) => {
+                const element = this.elementRef.nativeElement;
+                if (event.target !== element && !element.contains(event.target)) {
+                    this.hide();
+                }
+            });
+        }
+        // Tell the instance current position (left, right, top, bottom)
+        this.currentPosition$.pipe(takeUntil(this.tooltipInstanceDestroyed$)).subscribe((position) => {
+            this.ngZone.run(() => {
+                if (!this.tooltipRef) {
+                    return;
+                }
+                this.tooltipRef.setInput('position', position);
+                this.tooltipRef.setInput('offset', this.offset);
+            });
+        });
+    }
+    hide() {
+        if (!this.overlayRef?.hasAttached()) {
+            return;
+        }
+        this.overlayRef.detach();
+        this.tooltipInstanceDestroyed$.next();
+        this.tooltipInstanceDestroyed$.complete();
+        this.outputSubscription?.unsubscribe();
+        this.tooltipRef = undefined;
+    }
+    toggle() {
+        if (!this.overlayRef?.hasAttached()) {
+            this.show();
+            return;
+        }
+        this.hide();
+    }
+    handleMouseClick() {
+        if (this.showControlMode !== 'click' || this.disabled || !this._content) {
+            return;
+        }
+        this.toggle();
+    }
+    handleMouseEnter() {
+        if (this.showControlMode !== 'hover' || this.disabled || !this._content) {
+            return;
+        }
+        this.mouseOver = true;
+        this.show();
+    }
+    handleMouseLeave() {
+        if (this.hideControlMode !== 'hover' || this.disabled) {
+            return;
+        }
+        this.mouseOver = false;
+        setTimeout(() => this.softHide());
+    }
+    /**
+     * hides only if mouse is not over the host element nor the tooltip itself
+     */
+    softHide() {
+        if (!this.mouseOver && !this.tooltipInstance?.mouseOver()) {
+            this.hide();
+        }
+    }
+    createOverlay() {
+        if (this.overlayRef) {
+            return this.overlayRef;
+        }
+        const positionStrategy = this.overlay
+            .position()
+            .flexibleConnectedTo(this.elementRef);
+        positionStrategy.positionChanges.subscribe(console.log);
+        this.currentPosition$ = positionStrategy.positionChanges.pipe(map((pos) => pos.connectionPair.panelClass));
+        const scrollStrategy = this.overlay.scrollStrategies.reposition();
+        this.overlayRef = this.overlay.create({ positionStrategy, scrollStrategy });
+        if (this.showControlMode !== 'none') {
+            this.overlayRef
+                .keydownEvents()
+                .pipe(takeUntil(this.destroyed$))
+                .subscribe((event) => {
+                if (this.overlayRef?.hasAttached() &&
+                    event.keyCode === ESCAPE &&
+                    !hasModifierKey(event)) {
+                    this.hide();
+                }
+            });
+        }
+        this.updatePosition();
+        return this.overlayRef;
+    }
+    updateTooltipPlacement() {
+        if (this.overlayRef) {
+            this.updatePosition();
+            this.overlayRef.updatePosition();
+        }
+    }
+    updatePosition() {
+        const position = this.overlayRef.getConfig()
+            .positionStrategy;
+        const positions = this.getPositions(this._placement);
+        position.withPositions(positions);
+    }
+    getPositions(preferredPlacement) {
+        let positionedOverlayY;
+        let positionedOffsetY;
+        if (preferredPlacement.endsWith('start')) {
+            positionedOverlayY = 'top';
+            positionedOffsetY = -24;
+        }
+        else if (preferredPlacement.endsWith('end')) {
+            positionedOverlayY = 'bottom';
+            positionedOffsetY = 24;
+        }
+        else {
+            positionedOverlayY = 'center';
+            positionedOffsetY = 0;
+        }
+        let positionedOverlayX;
+        let positionedOffsetX;
+        if (preferredPlacement.endsWith('start')) {
+            positionedOverlayX = 'start';
+            positionedOffsetX = -24;
+        }
+        else if (preferredPlacement.endsWith('end')) {
+            positionedOverlayX = 'end';
+            positionedOffsetX = 24;
+        }
+        else {
+            positionedOffsetX = 0;
+            positionedOverlayX = 'center';
+        }
+        const right = {
+            originX: 'end',
+            originY: 'center',
+            overlayX: 'start',
+            overlayY: positionedOverlayY,
+            offsetY: positionedOffsetY,
+            panelClass: `right-${positionedOverlayY}`,
+        };
+        const left = {
+            originX: 'start',
+            originY: 'center',
+            overlayX: 'end',
+            overlayY: positionedOverlayY,
+            offsetY: positionedOffsetY,
+            panelClass: `left-${positionedOverlayY}`,
+        };
+        const top = {
+            originX: 'center',
+            originY: 'top',
+            overlayX: positionedOverlayX,
+            overlayY: 'bottom',
+            offsetX: positionedOffsetX,
+            panelClass: `top-${positionedOverlayX}`,
+        };
+        const bottom = {
+            originX: 'center',
+            originY: 'bottom',
+            overlayX: positionedOverlayX,
+            overlayY: 'top',
+            offsetX: positionedOffsetX,
+            panelClass: `bottom-${positionedOverlayX}`,
+        };
+        if (preferredPlacement.startsWith('right')) {
+            return [right, left, bottom, top];
+        }
+        else if (preferredPlacement.startsWith('left')) {
+            return [left, right, bottom, top];
+        }
+        else if (preferredPlacement.startsWith('top')) {
+            return [top, bottom, right, left];
+        }
+        else {
+            return [bottom, top, right, left];
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "19.0.1", type: GaTooltipDirective, isStandalone: true, selector: "[gaTooltip]", inputs: { content: ["gaTooltip", "content"], disabled: ["gaTooltipDisabled", "disabled", booleanAttribute], controlMode: ["gaTooltipControlMode", "controlMode"], showControlMode: ["gaTooltipShowControlMode", "showControlMode"], hideControlMode: ["gaTooltipHideControlMode", "hideControlMode"], offset: ["gaTooltipOffsetSize", "offset", numberAttribute], placement: ["gaTooltipPlacement", "placement"] }, host: { listeners: { "click": "handleMouseClick()", "mouseenter": "handleMouseEnter()", "mouseleave": "handleMouseLeave()" } }, exportAs: ["gaTooltip"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gaTooltip]',
+                    exportAs: 'gaTooltip',
+                }]
+        }], propDecorators: { content: [{
+                type: Input,
+                args: ['gaTooltip']
+            }], disabled: [{
+                type: Input,
+                args: [{ alias: 'gaTooltipDisabled', transform: booleanAttribute }]
+            }], controlMode: [{
+                type: Input,
+                args: [{ alias: 'gaTooltipControlMode' }]
+            }], showControlMode: [{
+                type: Input,
+                args: [{ alias: 'gaTooltipShowControlMode' }]
+            }], hideControlMode: [{
+                type: Input,
+                args: [{ alias: 'gaTooltipHideControlMode' }]
+            }], offset: [{
+                type: Input,
+                args: [{ alias: 'gaTooltipOffsetSize', transform: numberAttribute }]
+            }], placement: [{
+                type: Input,
+                args: [{ alias: 'gaTooltipPlacement' }]
+            }], handleMouseClick: [{
+                type: HostListener,
+                args: ['click']
+            }], handleMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], handleMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+
+class GaTooltipModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipModule, imports: [GaTooltipDirective], exports: [GaTooltipDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.1", ngImport: i0, type: GaTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [GaTooltipDirective],
+                    exports: [GaTooltipDirective],
+                }]
+        }] });
+
+/*
+ * Public API Surface of ngx-gaia
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CHECKBOX_CONTROL_VALUE_ACCESSOR, GA_CHECKBOX_REQUIRED_VALIDATOR, GA_FORM_CONTROL, GaButtonDirective, GaButtonModule, GaCheckboxComponent, GaCheckboxModule, GaCheckboxRequiredValidator, GaFieldInfoComponent, GaFieldLabelComponent, GaFormControlDirective, GaFormFieldComponent, GaFormFieldModule, GaIconButtonDirective, GaInputComponent, GaInputDirective, GaInputModule, GaMenuComponent, GaMenuItemComponent, GaMenuModule, GaMenuSeparatorComponent, GaMenuTriggerDirective, GaSegmentedControlButtonDirective, GaSegmentedControlComponent, GaSegmentedControlModule, GaTooltipComponent, GaTooltipDirective, GaTooltipModule };
+//# sourceMappingURL=vsn-ux-ngx-gaia.mjs.map