@spartan-ng/brain 0.0.1-alpha.373 → 0.0.1-alpha.379

package/esm2022/tabs/lib/brn-tabs-trigger.directive.mjs

@@ -0,0 +1,134 @@
+import { Directive, ElementRef, Input, computed, effect, inject, input, model, output, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BrnTabsContentDirective {
+    _root = inject(BrnTabsDirective);
+    _elementRef = inject(ElementRef);
+    contentFor = input.required({ alias: 'brnTabsContent' });
+    _isSelected = computed(() => this._root.$activeTab() === this.contentFor());
+    contentId = computed(() => `brn-tabs-content-${this.contentFor()}`);
+    labelId = computed(() => `brn-tabs-label-${this.contentFor()}`);
+    constructor() {
+        effect(() => {
+            this._root.registerContent(this.contentFor(), this);
+        }, { allowSignalWrites: true });
+    }
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: BrnTabsContentDirective, isStandalone: true, selector: "[brnTabsContent]", inputs: { contentFor: { classPropertyName: "contentFor", publicName: "brnTabsContent", isSignal: true, isRequired: true, transformFunction: null } }, host: { attributes: { "role": "tabpanel", "tabindex": "0" }, properties: { "id": "contentId()", "attr.aria-labelledby": "labelId()", "hidden": "_isSelected() === false" } }, exportAs: ["brnTabsContent"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnTabsContent]',
+                    standalone: true,
+                    host: {
+                        role: 'tabpanel',
+                        tabindex: '0',
+                        '[id]': 'contentId()',
+                        '[attr.aria-labelledby]': 'labelId()',
+                        '[hidden]': '_isSelected() === false',
+                    },
+                    exportAs: 'brnTabsContent',
+                }]
+        }], ctorParameters: () => [] });
+export class BrnTabsDirective {
+    orientation = input('horizontal');
+    /** internal **/
+    $orientation = this.orientation;
+    direction = input('ltr');
+    /** internal **/
+    $direction = this.direction;
+    _activeTab = model(undefined, { alias: 'brnTabs' });
+    /** internal **/
+    $activeTab = this._activeTab.asReadonly();
+    activationMode = input('automatic');
+    /** internal **/
+    $activationMode = this.activationMode;
+    tabActivated = output();
+    _tabs = signal({});
+    $tabs = this._tabs.asReadonly();
+    registerTrigger(key, trigger) {
+        this._tabs.update((tabs) => ({ ...tabs, [key]: { trigger, content: tabs[key]?.content } }));
+    }
+    registerContent(key, content) {
+        this._tabs.update((tabs) => ({ ...tabs, [key]: { trigger: tabs[key]?.trigger, content } }));
+    }
+    emitTabActivated(key) {
+        this.tabActivated.emit(key);
+    }
+    setActiveTab(key) {
+        this._activeTab.set(key);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: BrnTabsDirective, isStandalone: true, selector: "[brnTabs]", inputs: { orientation: { classPropertyName: "orientation", publicName: "orientation", isSignal: true, isRequired: false, transformFunction: null }, direction: { classPropertyName: "direction", publicName: "direction", isSignal: true, isRequired: false, transformFunction: null }, _activeTab: { classPropertyName: "_activeTab", publicName: "brnTabs", isSignal: true, isRequired: false, transformFunction: null }, activationMode: { classPropertyName: "activationMode", publicName: "activationMode", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { _activeTab: "brnTabsChange", tabActivated: "tabActivated" }, host: { properties: { "attr.data-orientation": "orientation()", "attr.dir": "direction()" } }, exportAs: ["brnTabs"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnTabs]',
+                    standalone: true,
+                    host: {
+                        '[attr.data-orientation]': 'orientation()',
+                        '[attr.dir]': 'direction()',
+                    },
+                    exportAs: 'brnTabs',
+                }]
+        }] });
+export class BrnTabsTriggerDirective {
+    elementRef = inject(ElementRef);
+    _root = inject(BrnTabsDirective);
+    _orientation = this._root.$orientation;
+    triggerFor = input.required({ alias: 'brnTabsTrigger' });
+    selected = computed(() => this._root.$activeTab() === this.triggerFor());
+    contentId = computed(() => `brn-tabs-content-${this.triggerFor()}`);
+    labelId = computed(() => `brn-tabs-label-${this.triggerFor()}`);
+    // leaving this as an @input to be compatible with the `FocusKeyManager` used in the `BrnTabsListDirective`
+    disabled = false;
+    constructor() {
+        effect(() => {
+            this._root.registerTrigger(this.triggerFor(), this);
+        }, { allowSignalWrites: true });
+    }
+    focus() {
+        this.elementRef.nativeElement.focus();
+        if (this._root.$activationMode() === 'automatic') {
+            this.activate();
+        }
+    }
+    activate() {
+        if (!this.triggerFor())
+            return;
+        this._root.setActiveTab(this.triggerFor());
+        this._root.emitTabActivated(this.triggerFor());
+    }
+    get key() {
+        return this.triggerFor();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: BrnTabsTriggerDirective, isStandalone: true, selector: "button[brnTabsTrigger]", inputs: { triggerFor: { classPropertyName: "triggerFor", publicName: "brnTabsTrigger", isSignal: true, isRequired: true, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: false, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button", "role": "tab" }, listeners: { "click": "activate()" }, properties: { "id": "labelId()", "tabindex": "selected() ? \"0\": \"-1\"", "attr.aria-selected": "selected()", "attr.aria-controls": "contentId()", "attr.data-state": "selected() ? 'active' : 'inactive'", "attr.data-orientation": "_orientation()", "attr.data-disabled": "disabled ? '' : undefined" } }, exportAs: ["brnTabsTrigger"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[brnTabsTrigger]',
+                    standalone: true,
+                    host: {
+                        '[id]': 'labelId()',
+                        type: 'button',
+                        role: 'tab',
+                        '[tabindex]': 'selected() ? "0": "-1"',
+                        '[attr.aria-selected]': 'selected()',
+                        '[attr.aria-controls]': 'contentId()',
+                        '[attr.data-state]': "selected() ? 'active' : 'inactive'",
+                        '[attr.data-orientation]': '_orientation()',
+                        '[attr.data-disabled]': "disabled ? '' : undefined",
+                        '(click)': 'activate()',
+                    },
+                    exportAs: 'brnTabsTrigger',
+                }]
+        }], ctorParameters: () => [], propDecorators: { disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-tabs-trigger.directive.js","sourceRoot":"","sources":["../../../../../../libs/brain/tabs/src/lib/brn-tabs-trigger.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Input, computed, effect, inject, input, model, output, signal } from '@angular/core';\n\n@Directive({\n\tselector: '[brnTabsContent]',\n\tstandalone: true,\n\thost: {\n\t\trole: 'tabpanel',\n\t\ttabindex: '0',\n\t\t'[id]': 'contentId()',\n\t\t'[attr.aria-labelledby]': 'labelId()',\n\t\t'[hidden]': '_isSelected() === false',\n\t},\n\texportAs: 'brnTabsContent',\n})\nexport class BrnTabsContentDirective {\n\tprivate readonly _root = inject(BrnTabsDirective);\n\tprivate readonly _elementRef = inject(ElementRef);\n\n\tpublic readonly contentFor = input.required<string>({ alias: 'brnTabsContent' });\n\tprotected readonly _isSelected = computed(() => this._root.$activeTab() === this.contentFor());\n\tprotected contentId = computed(() => `brn-tabs-content-${this.contentFor()}`);\n\tprotected labelId = computed(() => `brn-tabs-label-${this.contentFor()}`);\n\n\tconstructor() {\n\t\teffect(\n\t\t\t() => {\n\t\t\t\tthis._root.registerContent(this.contentFor(), this);\n\t\t\t},\n\t\t\t{ allowSignalWrites: true },\n\t\t);\n\t}\n\n\tpublic focus() {\n\t\tthis._elementRef.nativeElement.focus();\n\t}\n}\n\nexport type BrnTabsOrientation = 'horizontal' | 'vertical';\nexport type BrnTabsDirection = 'ltr' | 'rtl';\nexport type BrnActivationMode = 'automatic' | 'manual';\n\n@Directive({\n\tselector: '[brnTabs]',\n\tstandalone: true,\n\thost: {\n\t\t'[attr.data-orientation]': 'orientation()',\n\t\t'[attr.dir]': 'direction()',\n\t},\n\texportAs: 'brnTabs',\n})\nexport class BrnTabsDirective {\n\tpublic readonly orientation = input<BrnTabsOrientation>('horizontal');\n\t/** internal **/\n\tpublic $orientation = this.orientation;\n\n\tpublic readonly direction = input<BrnTabsDirection>('ltr');\n\t/** internal **/\n\tpublic $direction = this.direction;\n\n\tpublic readonly _activeTab = model<string | undefined>(undefined, { alias: 'brnTabs' });\n\t/** internal **/\n\tpublic $activeTab = this._activeTab.asReadonly();\n\n\tpublic readonly activationMode = input<BrnActivationMode>('automatic');\n\t/** internal **/\n\tpublic $activationMode = this.activationMode;\n\n\tpublic readonly tabActivated = output<string>();\n\n\tprivate readonly _tabs = signal<{\n\t\t[key: string]: { trigger: BrnTabsTriggerDirective; content: BrnTabsContentDirective };\n\t}>({});\n\tpublic readonly $tabs = this._tabs.asReadonly();\n\n\tpublic registerTrigger(key: string, trigger: BrnTabsTriggerDirective) {\n\t\tthis._tabs.update((tabs) => ({ ...tabs, [key]: { trigger, content: tabs[key]?.content } }));\n\t}\n\n\tpublic registerContent(key: string, content: BrnTabsContentDirective) {\n\t\tthis._tabs.update((tabs) => ({ ...tabs, [key]: { trigger: tabs[key]?.trigger, content } }));\n\t}\n\n\temitTabActivated(key: string) {\n\t\tthis.tabActivated.emit(key);\n\t}\n\n\tsetActiveTab(key: string) {\n\t\tthis._activeTab.set(key);\n\t}\n}\n\n@Directive({\n\tselector: 'button[brnTabsTrigger]',\n\tstandalone: true,\n\thost: {\n\t\t'[id]': 'labelId()',\n\t\ttype: 'button',\n\t\trole: 'tab',\n\t\t'[tabindex]': 'selected() ? \"0\": \"-1\"',\n\t\t'[attr.aria-selected]': 'selected()',\n\t\t'[attr.aria-controls]': 'contentId()',\n\t\t'[attr.data-state]': \"selected() ? 'active' : 'inactive'\",\n\t\t'[attr.data-orientation]': '_orientation()',\n\t\t'[attr.data-disabled]': \"disabled ? '' : undefined\",\n\t\t'(click)': 'activate()',\n\t},\n\texportAs: 'brnTabsTrigger',\n})\nexport class BrnTabsTriggerDirective {\n\tpublic readonly elementRef = inject(ElementRef);\n\n\tprivate readonly _root = inject(BrnTabsDirective);\n\n\tprotected readonly _orientation = this._root.$orientation;\n\n\tpublic readonly triggerFor = input.required<string>({ alias: 'brnTabsTrigger' });\n\tpublic readonly selected = computed(() => this._root.$activeTab() === this.triggerFor());\n\tprotected readonly contentId = computed(() => `brn-tabs-content-${this.triggerFor()}`);\n\tprotected readonly labelId = computed(() => `brn-tabs-label-${this.triggerFor()}`);\n\n\t// leaving this as an @input to be compatible with the `FocusKeyManager` used in the `BrnTabsListDirective`\n\t@Input()\n\tpublic disabled = false;\n\n\tconstructor() {\n\t\teffect(\n\t\t\t() => {\n\t\t\t\tthis._root.registerTrigger(this.triggerFor(), this);\n\t\t\t},\n\t\t\t{ allowSignalWrites: true },\n\t\t);\n\t}\n\n\tpublic focus() {\n\t\tthis.elementRef.nativeElement.focus();\n\t\tif (this._root.$activationMode() === 'automatic') {\n\t\t\tthis.activate();\n\t\t}\n\t}\n\n\tpublic activate() {\n\t\tif (!this.triggerFor()) return;\n\t\tthis._root.setActiveTab(this.triggerFor());\n\t\tthis._root.emitTabActivated(this.triggerFor());\n\t}\n\n\tpublic get key(): string | undefined {\n\t\treturn this.triggerFor();\n\t}\n}\n"]}

package/esm2022/tabs/spartan-ng-brain-tabs.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhcnRhbi1uZy1icmFpbi10YWJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9icmFpbi90YWJzL3NyYy9zcGFydGFuLW5nLWJyYWluLXRhYnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/toggle/index.mjs

@@ -0,0 +1,31 @@
+import { NgModule } from '@angular/core';
+import { BrnToggleGroupComponent } from './lib/brn-toggle-group.component';
+import { BrnToggleDirective } from './lib/brn-toggle.directive';
+import * as i0 from "@angular/core";
+export * from './lib/brn-toggle-group.component';
+export * from './lib/brn-toggle.directive';
+export class BrnToggleModule {
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleModule, imports: [BrnToggleDirective], exports: [BrnToggleDirective] });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [BrnToggleDirective],
+                    exports: [BrnToggleDirective],
+                }]
+        }] });
+export class BrnToggleGroupModule {
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleGroupModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleGroupModule, imports: [BrnToggleDirective, BrnToggleGroupComponent], exports: [BrnToggleDirective, BrnToggleGroupComponent] });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleGroupModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleGroupModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [BrnToggleDirective, BrnToggleGroupComponent],
+                    exports: [BrnToggleDirective, BrnToggleGroupComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL3RvZ2dsZS9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUMzRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQzs7QUFFaEUsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDRCQUE0QixDQUFDO0FBTTNDLE1BQU0sT0FBTyxlQUFlOzBIQUFmLGVBQWU7MkhBQWYsZUFBZSxZQUhqQixrQkFBa0IsYUFDbEIsa0JBQWtCOzJIQUVoQixlQUFlOzsyRkFBZixlQUFlO2tCQUozQixRQUFRO21CQUFDO29CQUNULE9BQU8sRUFBRSxDQUFDLGtCQUFrQixDQUFDO29CQUM3QixPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQztpQkFDN0I7O0FBT0QsTUFBTSxPQUFPLG9CQUFvQjswSEFBcEIsb0JBQW9COzJIQUFwQixvQkFBb0IsWUFIdEIsa0JBQWtCLEVBQUUsdUJBQXVCLGFBQzNDLGtCQUFrQixFQUFFLHVCQUF1QjsySEFFekMsb0JBQW9COzsyRkFBcEIsb0JBQW9CO2tCQUpoQyxRQUFRO21CQUFDO29CQUNULE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLHVCQUF1QixDQUFDO29CQUN0RCxPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSx1QkFBdUIsQ0FBQztpQkFDdEQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQnJuVG9nZ2xlR3JvdXBDb21wb25lbnQgfSBmcm9tICcuL2xpYi9icm4tdG9nZ2xlLWdyb3VwLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBCcm5Ub2dnbGVEaXJlY3RpdmUgfSBmcm9tICcuL2xpYi9icm4tdG9nZ2xlLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2Jybi10b2dnbGUtZ3JvdXAuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Jybi10b2dnbGUuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcblx0aW1wb3J0czogW0JyblRvZ2dsZURpcmVjdGl2ZV0sXG5cdGV4cG9ydHM6IFtCcm5Ub2dnbGVEaXJlY3RpdmVdLFxufSlcbmV4cG9ydCBjbGFzcyBCcm5Ub2dnbGVNb2R1bGUge31cblxuQE5nTW9kdWxlKHtcblx0aW1wb3J0czogW0JyblRvZ2dsZURpcmVjdGl2ZSwgQnJuVG9nZ2xlR3JvdXBDb21wb25lbnRdLFxuXHRleHBvcnRzOiBbQnJuVG9nZ2xlRGlyZWN0aXZlLCBCcm5Ub2dnbGVHcm91cENvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIEJyblRvZ2dsZUdyb3VwTW9kdWxlIHt9XG4iXX0=

package/esm2022/toggle/lib/brn-toggle-group.component.mjs

@@ -0,0 +1,159 @@
+import { Component, booleanAttribute, computed, forwardRef, input, model, output, signal } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { provideBrnToggleGroup } from './brn-toggle-group.token';
+import * as i0 from "@angular/core";
+export const BRN_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => BrnToggleGroupComponent),
+    multi: true,
+};
+export class BrnButtonToggleChange {
+    source;
+    value;
+    constructor(source, value) {
+        this.source = source;
+        this.value = value;
+    }
+}
+export class BrnToggleGroupComponent {
+    /**
+     * The method to be called in order to update ngModel.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    _onChange = () => { };
+    /** onTouch function registered via registerOnTouch (ControlValueAccessor). */
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    onTouched = () => { };
+    /** Whether the button toggle group has a vertical orientation */
+    vertical = input(false, {
+        transform: booleanAttribute,
+    });
+    /** Value of the toggle group. */
+    value = model(undefined);
+    /** Whether no button toggles need to be selected. */
+    nullable = input(false, {
+        transform: booleanAttribute,
+    });
+    /** Whether multiple button toggles can be selected. */
+    multiple = input(false, {
+        transform: booleanAttribute,
+    });
+    /** Whether the button toggle group is disabled. */
+    disabled = input(false, {
+        transform: booleanAttribute,
+    });
+    /** The internal state of the component. This can be replaced with linkedSignal in the future. */
+    state = computed(() => ({
+        disabled: signal(this.disabled()),
+    }));
+    /** Emit event when the group value changes. */
+    change = output();
+    writeValue(value) {
+        this.value.set(value);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.state().disabled.set(isDisabled);
+    }
+    /**
+     * @internal
+     * Determines whether a value can be set on the group.
+     */
+    canDeselect(value) {
+        // if null values are allowed, the group can always be nullable
+        if (this.nullable())
+            return true;
+        const currentValue = this.value();
+        if (this.multiple() && Array.isArray(currentValue)) {
+            return !(currentValue.length === 1 && currentValue[0] === value);
+        }
+        return currentValue !== value;
+    }
+    /**
+     * @internal
+     * Selects a value.
+     */
+    select(value, source) {
+        if (this.state().disabled() || this.isSelected(value)) {
+            return;
+        }
+        const currentValue = this.value();
+        // emit the valueChange event here as we should only emit based on user interaction
+        if (this.multiple()) {
+            this.emitSelectionChange([...(currentValue ?? []), value], source);
+        }
+        else {
+            this.emitSelectionChange(value, source);
+        }
+        this._onChange(this.value());
+        this.change.emit(new BrnButtonToggleChange(source, this.value()));
+    }
+    /**
+     * @internal
+     * Deselects a value.
+     */
+    deselect(value, source) {
+        if (this.state().disabled() || !this.isSelected(value) || !this.canDeselect(value)) {
+            return;
+        }
+        const currentValue = this.value();
+        if (this.multiple()) {
+            this.emitSelectionChange((currentValue ?? []).filter((v) => v !== value), source);
+        }
+        else if (currentValue === value) {
+            this.emitSelectionChange(null, source);
+        }
+    }
+    /**
+     * @internal
+     * Determines whether a value is selected.
+     */
+    isSelected(value) {
+        const currentValue = this.value();
+        if (currentValue == null ||
+            currentValue === undefined ||
+            (Array.isArray(currentValue) && currentValue.length === 0)) {
+            return false;
+        }
+        if (this.multiple()) {
+            return currentValue?.includes(value);
+        }
+        return currentValue === value;
+    }
+    /** Update the value of the group */
+    emitSelectionChange(value, source) {
+        this.value.set(value);
+        this._onChange(value);
+        this.change.emit(new BrnButtonToggleChange(source, this.value()));
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleGroupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.5", type: BrnToggleGroupComponent, isStandalone: true, selector: "brn-toggle-group", inputs: { vertical: { classPropertyName: "vertical", publicName: "vertical", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, nullable: { classPropertyName: "nullable", publicName: "nullable", isSignal: true, isRequired: false, transformFunction: null }, multiple: { classPropertyName: "multiple", publicName: "multiple", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", change: "change" }, host: { attributes: { "role": "group" }, listeners: { "focusout": "onTouched()" }, properties: { "attr.aria-disabled": "state().disabled()", "attr.data-disabled": "state().disabled()", "attr.data-vertical": "vertical()" }, classAttribute: "brn-button-toggle-group" }, providers: [provideBrnToggleGroup(BrnToggleGroupComponent), BRN_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR], exportAs: ["brnToggleGroup"], ngImport: i0, template: `
+		<ng-content />
+	`, isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleGroupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'brn-toggle-group',
+                    standalone: true,
+                    providers: [provideBrnToggleGroup(BrnToggleGroupComponent), BRN_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR],
+                    host: {
+                        role: 'group',
+                        class: 'brn-button-toggle-group',
+                        '[attr.aria-disabled]': 'state().disabled()',
+                        '[attr.data-disabled]': 'state().disabled()',
+                        '[attr.data-vertical]': 'vertical()',
+                        '(focusout)': 'onTouched()',
+                    },
+                    exportAs: 'brnToggleGroup',
+                    template: `
+		<ng-content />
+	`,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-toggle-group.component.js","sourceRoot":"","sources":["../../../../../../libs/brain/toggle/src/lib/brn-toggle-group.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput } from '@angular/cdk/coercion';\nimport { Component, booleanAttribute, computed, forwardRef, input, model, output, signal } from '@angular/core';\nimport { type ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { provideBrnToggleGroup } from './brn-toggle-group.token';\nimport { BrnToggleDirective } from './brn-toggle.directive';\n\nexport const BRN_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR = {\n\tprovide: NG_VALUE_ACCESSOR,\n\tuseExisting: forwardRef(() => BrnToggleGroupComponent),\n\tmulti: true,\n};\n\nexport class BrnButtonToggleChange<T = unknown> {\n\tconstructor(\n\t\tpublic source: BrnToggleDirective<T>,\n\t\tpublic value: ToggleValue<T>,\n\t) {}\n}\n\n@Component({\n\tselector: 'brn-toggle-group',\n\tstandalone: true,\n\tproviders: [provideBrnToggleGroup(BrnToggleGroupComponent), BRN_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR],\n\thost: {\n\t\trole: 'group',\n\t\tclass: 'brn-button-toggle-group',\n\t\t'[attr.aria-disabled]': 'state().disabled()',\n\t\t'[attr.data-disabled]': 'state().disabled()',\n\t\t'[attr.data-vertical]': 'vertical()',\n\t\t'(focusout)': 'onTouched()',\n\t},\n\texportAs: 'brnToggleGroup',\n\ttemplate: `\n\t\t<ng-content />\n\t`,\n})\nexport class BrnToggleGroupComponent<T = unknown> implements ControlValueAccessor {\n\t/**\n\t * The method to be called in order to update ngModel.\n\t */\n\t// eslint-disable-next-line @typescript-eslint/no-empty-function\n\tprivate _onChange: (value: ToggleValue<T>) => void = () => {};\n\n\t/** onTouch function registered via registerOnTouch (ControlValueAccessor). */\n\t// eslint-disable-next-line @typescript-eslint/no-empty-function\n\tprotected onTouched: () => void = () => {};\n\n\t/** Whether the button toggle group has a vertical orientation */\n\tpublic readonly vertical = input<boolean, BooleanInput>(false, {\n\t\ttransform: booleanAttribute,\n\t});\n\n\t/** Value of the toggle group. */\n\tpublic readonly value = model<ToggleValue<T>>(undefined);\n\n\t/** Whether no button toggles need to be selected. */\n\tpublic readonly nullable = input<boolean, BooleanInput>(false, {\n\t\ttransform: booleanAttribute,\n\t});\n\n\t/** Whether multiple button toggles can be selected. */\n\tpublic readonly multiple = input<boolean, BooleanInput>(false, {\n\t\ttransform: booleanAttribute,\n\t});\n\n\t/** Whether the button toggle group is disabled. */\n\tpublic readonly disabled = input<boolean, BooleanInput>(false, {\n\t\ttransform: booleanAttribute,\n\t});\n\n\t/** The internal state of the component. This can be replaced with linkedSignal in the future. */\n\tpublic readonly state = computed(() => ({\n\t\tdisabled: signal(this.disabled()),\n\t}));\n\n\t/** Emit event when the group value changes. */\n\tpublic readonly change = output<BrnButtonToggleChange<T>>();\n\n\twriteValue(value: ToggleValue<T>): void {\n\t\tthis.value.set(value);\n\t}\n\n\tregisterOnChange(fn: (value: ToggleValue<T>) => void) {\n\t\tthis._onChange = fn;\n\t}\n\n\tregisterOnTouched(fn: () => void) {\n\t\tthis.onTouched = fn;\n\t}\n\n\tsetDisabledState(isDisabled: boolean): void {\n\t\tthis.state().disabled.set(isDisabled);\n\t}\n\n\t/**\n\t * @internal\n\t * Determines whether a value can be set on the group.\n\t */\n\tcanDeselect(value: ToggleValue<T>): boolean {\n\t\t// if null values are allowed, the group can always be nullable\n\t\tif (this.nullable()) return true;\n\n\t\tconst currentValue = this.value();\n\n\t\tif (this.multiple() && Array.isArray(currentValue)) {\n\t\t\treturn !(currentValue.length === 1 && currentValue[0] === value);\n\t\t}\n\n\t\treturn currentValue !== value;\n\t}\n\n\t/**\n\t * @internal\n\t * Selects a value.\n\t */\n\tselect(value: T, source: BrnToggleDirective<T>): void {\n\t\tif (this.state().disabled() || this.isSelected(value)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst currentValue = this.value();\n\n\t\t// emit the valueChange event here as we should only emit based on user interaction\n\t\tif (this.multiple()) {\n\t\t\tthis.emitSelectionChange([...((currentValue ?? []) as T[]), value], source);\n\t\t} else {\n\t\t\tthis.emitSelectionChange(value, source);\n\t\t}\n\n\t\tthis._onChange(this.value());\n\t\tthis.change.emit(new BrnButtonToggleChange<T>(source, this.value()));\n\t}\n\n\t/**\n\t * @internal\n\t * Deselects a value.\n\t */\n\tdeselect(value: T, source: BrnToggleDirective<T>): void {\n\t\tif (this.state().disabled() || !this.isSelected(value) || !this.canDeselect(value)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst currentValue = this.value();\n\n\t\tif (this.multiple()) {\n\t\t\tthis.emitSelectionChange(\n\t\t\t\t((currentValue ?? []) as T[]).filter((v) => v !== value),\n\t\t\t\tsource,\n\t\t\t);\n\t\t} else if (currentValue === value) {\n\t\t\tthis.emitSelectionChange(null, source);\n\t\t}\n\t}\n\n\t/**\n\t * @internal\n\t * Determines whether a value is selected.\n\t */\n\tisSelected(value: T): boolean {\n\t\tconst currentValue = this.value();\n\n\t\tif (\n\t\t\tcurrentValue == null ||\n\t\t\tcurrentValue === undefined ||\n\t\t\t(Array.isArray(currentValue) && currentValue.length === 0)\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\n\t\tif (this.multiple()) {\n\t\t\treturn (currentValue as T[])?.includes(value);\n\t\t}\n\t\treturn currentValue === value;\n\t}\n\n\t/** Update the value of the group */\n\tprivate emitSelectionChange(value: ToggleValue<T>, source: BrnToggleDirective<T>): void {\n\t\tthis.value.set(value);\n\t\tthis._onChange(value);\n\t\tthis.change.emit(new BrnButtonToggleChange<T>(source, this.value()));\n\t}\n}\n\ntype ToggleValue<T> = T | T[] | null | undefined;\n"]}

package/esm2022/toggle/lib/brn-toggle-group.token.mjs

@@ -0,0 +1,9 @@
+import { InjectionToken, inject } from '@angular/core';
+const BrnToggleGroupToken = new InjectionToken('BrnToggleGroupToken');
+export function injectBrnToggleGroup() {
+    return inject(BrnToggleGroupToken, { optional: true });
+}
+export function provideBrnToggleGroup(value) {
+    return { provide: BrnToggleGroupToken, useExisting: value };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJuLXRvZ2dsZS1ncm91cC50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYnJhaW4vdG9nZ2xlL3NyYy9saWIvYnJuLXRvZ2dsZS1ncm91cC50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQW9CLGNBQWMsRUFBUSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHL0UsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLGNBQWMsQ0FBMEIscUJBQXFCLENBQUMsQ0FBQztBQUUvRixNQUFNLFVBQVUsb0JBQW9CO0lBQ25DLE9BQU8sTUFBTSxDQUFDLG1CQUFtQixFQUFFLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFzQyxDQUFDO0FBQzdGLENBQUM7QUFFRCxNQUFNLFVBQVUscUJBQXFCLENBQUksS0FBdUM7SUFDL0UsT0FBTyxFQUFFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLENBQUM7QUFDN0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV4aXN0aW5nUHJvdmlkZXIsIEluamVjdGlvblRva2VuLCBUeXBlLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgQnJuVG9nZ2xlR3JvdXBDb21wb25lbnQgfSBmcm9tICcuL2Jybi10b2dnbGUtZ3JvdXAuY29tcG9uZW50JztcblxuY29uc3QgQnJuVG9nZ2xlR3JvdXBUb2tlbiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxCcm5Ub2dnbGVHcm91cENvbXBvbmVudD4oJ0JyblRvZ2dsZUdyb3VwVG9rZW4nKTtcblxuZXhwb3J0IGZ1bmN0aW9uIGluamVjdEJyblRvZ2dsZUdyb3VwPFQ+KCk6IEJyblRvZ2dsZUdyb3VwQ29tcG9uZW50PFQ+IHwgbnVsbCB7XG5cdHJldHVybiBpbmplY3QoQnJuVG9nZ2xlR3JvdXBUb2tlbiwgeyBvcHRpb25hbDogdHJ1ZSB9KSBhcyBCcm5Ub2dnbGVHcm91cENvbXBvbmVudDxUPiB8IG51bGw7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlQnJuVG9nZ2xlR3JvdXA8VD4odmFsdWU6IFR5cGU8QnJuVG9nZ2xlR3JvdXBDb21wb25lbnQ8VD4+KTogRXhpc3RpbmdQcm92aWRlciB7XG5cdHJldHVybiB7IHByb3ZpZGU6IEJyblRvZ2dsZUdyb3VwVG9rZW4sIHVzZUV4aXN0aW5nOiB2YWx1ZSB9O1xufVxuIl19

package/esm2022/toggle/lib/brn-toggle.directive.mjs

@@ -0,0 +1,65 @@
+import { ChangeDetectorRef, Directive, booleanAttribute, computed, inject, input, model } from '@angular/core';
+import { injectBrnToggleGroup } from './brn-toggle-group.token';
+import * as i0 from "@angular/core";
+export class BrnToggleDirective {
+    static _uniqueId = 0;
+    _changeDetector = inject(ChangeDetectorRef);
+    /** Access the toggle group if available. */
+    group = injectBrnToggleGroup();
+    /** The id of the toggle. */
+    id = input(`brn-toggle-${BrnToggleDirective._uniqueId++}`);
+    /** The value this toggle represents. */
+    value = input();
+    /** Whether the toggle is disabled. */
+    disabled = input(false, {
+        transform: booleanAttribute,
+    });
+    /** The current state of the toggle when not used in a group. */
+    state = model('off');
+    /** Whether the toggle is responds to click events. */
+    disableToggleClick = input(false, {
+        transform: booleanAttribute,
+    });
+    /** Whether the toggle is in the on state. */
+    isOn = computed(() => this._state() === 'on');
+    /** The current state that reflects the group state or the model state. */
+    _state = computed(() => {
+        if (this.group) {
+            return this.group.isSelected(this.value()) ? 'on' : 'off';
+        }
+        return this.state();
+    });
+    toggle() {
+        if (this.disableToggleClick())
+            return;
+        if (this.group) {
+            if (this.isOn()) {
+                this.group.deselect(this.value(), this);
+            }
+            else {
+                this.group.select(this.value(), this);
+            }
+        }
+        else {
+            this.state.set(this.isOn() ? 'off' : 'on');
+        }
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: BrnToggleDirective, isStandalone: true, selector: "button[hlmToggle], button[brnToggle]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, state: { classPropertyName: "state", publicName: "state", isSignal: true, isRequired: false, transformFunction: null }, disableToggleClick: { classPropertyName: "disableToggleClick", publicName: "disableToggleClick", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { state: "stateChange" }, host: { attributes: { "id": "id()" }, listeners: { "click": "toggle()" }, properties: { "attr.disabled": "disabled() || group?.disabled() ? true : null", "attr.data-disabled": "disabled() || group?.disabled() ? true : null", "attr.data-state": "_state()", "attr.aria-pressed": "isOn()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnToggleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[hlmToggle], button[brnToggle]',
+                    standalone: true,
+                    host: {
+                        id: 'id()',
+                        '[attr.disabled]': 'disabled() || group?.disabled() ? true : null',
+                        '[attr.data-disabled]': 'disabled() || group?.disabled() ? true : null',
+                        '[attr.data-state]': '_state()',
+                        '[attr.aria-pressed]': 'isOn()',
+                        '(click)': 'toggle()',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/toggle/spartan-ng-brain-toggle.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhcnRhbi1uZy1icmFpbi10b2dnbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL3RvZ2dsZS9zcmMvc3BhcnRhbi1uZy1icmFpbi10b2dnbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/tooltip/index.mjs

@@ -0,0 +1,35 @@
+import { NgModule } from '@angular/core';
+import { BrnTooltipContentComponent } from './lib/brn-tooltip-content.component';
+import { BrnTooltipContentDirective } from './lib/brn-tooltip-content.directive';
+import { BrnTooltipTriggerDirective } from './lib/brn-tooltip-trigger.directive';
+import { BrnTooltipDirective } from './lib/brn-tooltip.directive';
+import * as i0 from "@angular/core";
+export * from './lib/brn-tooltip-content.component';
+export * from './lib/brn-tooltip-content.directive';
+export * from './lib/brn-tooltip-trigger.directive';
+export * from './lib/brn-tooltip.directive';
+export const BrnTooltipImports = [
+    BrnTooltipDirective,
+    BrnTooltipContentDirective,
+    BrnTooltipTriggerDirective,
+    BrnTooltipContentComponent,
+];
+export class BrnTooltipModule {
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipModule, imports: [BrnTooltipDirective,
+            BrnTooltipContentDirective,
+            BrnTooltipTriggerDirective,
+            BrnTooltipContentComponent], exports: [BrnTooltipDirective,
+            BrnTooltipContentDirective,
+            BrnTooltipTriggerDirective,
+            BrnTooltipContentComponent] });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...BrnTooltipImports],
+                    exports: [...BrnTooltipImports],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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