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

package/table/lib/brn-column-manager.d.ts

@@ -0,0 +1,26 @@
+import { type Signal } from '@angular/core';
+type BrnColumnVisibility = Record<string, boolean> | Record<string, {
+    visible: boolean;
+}>;
+type AllColumnsPropertyType<T> = T extends Record<string, boolean> ? (keyof T)[] : T extends Record<string, infer R> ? (R extends {
+    visible: boolean;
+} ? {
+    name: keyof T;
+} & R : never)[] : never;
+export declare class BrnColumnManager<T extends BrnColumnVisibility> {
+    private readonly _initialColumnVisibility;
+    private readonly _columnVisibility;
+    readonly allColumns: AllColumnsPropertyType<T>;
+    readonly columnVisibility: Signal<T>;
+    readonly displayedColumns: Signal<(keyof T)[]>;
+    constructor(initialColumnVisibility: T);
+    readonly isColumnVisible: (columnName: string) => boolean;
+    readonly isColumnDisabled: (columnName: string) => boolean;
+    toggleVisibility(columnName: keyof T): void;
+    setVisible(columnName: keyof T): void;
+    setInvisible(columnName: keyof T): void;
+    private createAllColumns;
+    private isBooleanConfig;
+}
+export declare const useBrnColumnManager: <T extends BrnColumnVisibility>(initialColumnVisibility: T) => BrnColumnManager<T>;
+export {};

package/table/lib/brn-footer-def.directive.d.ts

@@ -0,0 +1,9 @@
+import { CdkFooterCellDef } from '@angular/cdk/table';
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BrnFooterDefDirective extends CdkFooterCellDef {
+    template: TemplateRef<unknown>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnFooterDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnFooterDefDirective, "[brnFooterDef]", ["brnFooterDef"], {}, {}, never, never, true, never>;
+}

package/table/lib/brn-header-def.directive.d.ts

@@ -0,0 +1,9 @@
+import { CdkHeaderCellDef } from '@angular/cdk/table';
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BrnHeaderDefDirective extends CdkHeaderCellDef {
+    template: TemplateRef<unknown>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnHeaderDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnHeaderDefDirective, "[brnHeaderDef]", ["brnHeaderDef"], {}, {}, never, never, true, never>;
+}

package/table/lib/brn-paginator.directive.d.ts

@@ -0,0 +1,41 @@
+import { type OnInit, type Signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export type PaginatorState = {
+    currentPage: number;
+    startIndex: number;
+    endIndex: number;
+    pageSize: number;
+    totalPages: number;
+    totalElements: number | null | undefined;
+};
+export type PaginatorContext = {
+    $implicit: {
+        state: Signal<PaginatorState>;
+        incrementable: Signal<boolean>;
+        decrementable: Signal<boolean>;
+        increment: () => void;
+        decrement: () => void;
+    };
+};
+export declare class BrnPaginatorDirective implements OnInit {
+    static ngTemplateContextGuard(_directive: BrnPaginatorDirective, _context: unknown): _context is PaginatorContext;
+    private readonly _vcr;
+    private readonly _template;
+    private readonly _state;
+    private readonly _decrementable;
+    private readonly _incrementable;
+    set totalElements(value: number | null | undefined);
+    set currentPage(value: number);
+    set pageSize(value: number);
+    onStateChange?: (state: PaginatorState) => void;
+    constructor();
+    ngOnInit(): void;
+    decrementPage(): void;
+    incrementPage(): void;
+    reset(): void;
+    private calculateNewState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnPaginatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnPaginatorDirective, "[brnPaginator]", ["brnPaginator"], { "totalElements": { "alias": "brnPaginatorTotalElements"; "required": false; }; "currentPage": { "alias": "brnPaginatorCurrentPage"; "required": false; }; "pageSize": { "alias": "brnPaginatorPageSize"; "required": false; }; "onStateChange": { "alias": "brnPaginatorOnStateChange"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_currentPage: unknown;
+    static ngAcceptInputType_pageSize: unknown;
+}

package/table/lib/brn-table.component.d.ts

@@ -0,0 +1,37 @@
+import { CdkRowDef, type CdkTableDataSourceInput } from '@angular/cdk/table';
+import { type AfterContentInit, EventEmitter, type QueryList, type TrackByFunction } from '@angular/core';
+import { type TableClassesSettable } from '@spartan-ng/ui-core';
+import { BrnColumnDefComponent } from './brn-column-def.component';
+import * as i0 from "@angular/core";
+export type BrnTableDataSourceInput<T> = CdkTableDataSourceInput<T>;
+export declare class BrnTableComponent<T> implements TableClassesSettable, AfterContentInit {
+    private readonly _cdkTable?;
+    dataSource: BrnTableDataSourceInput<T>;
+    fixedLayout: boolean;
+    multiTemplateDataRows: boolean;
+    displayedColumns: string[];
+    private _trackBy?;
+    get trackBy(): TrackByFunction<T> | undefined;
+    set trackBy(value: TrackByFunction<T>);
+    readonly contentChanged: EventEmitter<void>;
+    customTemplateDataRows: boolean;
+    onRowClick: ((element: T) => void) | undefined;
+    stickyHeader: boolean;
+    tableClasses: string;
+    headerRowClasses: string;
+    bodyRowClasses: string;
+    columnDefComponents: QueryList<BrnColumnDefComponent>;
+    rowDefs: QueryList<CdkRowDef<T>>;
+    ngAfterContentInit(): void;
+    setTableClasses({ table, headerRow, bodyRow, }: Partial<{
+        table: string;
+        headerRow: string;
+        bodyRow: string;
+    }>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BrnTableComponent<any>, "brn-table", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "fixedLayout": { "alias": "fixedLayout"; "required": false; }; "multiTemplateDataRows": { "alias": "multiTemplateDataRows"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "customTemplateDataRows": { "alias": "customTemplateDataRows"; "required": false; }; "onRowClick": { "alias": "onRowClick"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "tableClasses": { "alias": "tableClasses"; "required": false; }; "headerRowClasses": { "alias": "headerRowClasses"; "required": false; }; "bodyRowClasses": { "alias": "bodyRowClasses"; "required": false; }; }, { "contentChanged": "contentChanged"; }, ["columnDefComponents", "rowDefs"], ["*", "[brnNoDataRow]"], true, never>;
+    static ngAcceptInputType_fixedLayout: unknown;
+    static ngAcceptInputType_multiTemplateDataRows: unknown;
+    static ngAcceptInputType_customTemplateDataRows: unknown;
+    static ngAcceptInputType_stickyHeader: unknown;
+}

package/tabs/README.md

@@ -0,0 +1,3 @@
+# @spartan-ng/brain/tabs
+
+Secondary entry point of `@spartan-ng/brain`. It can be used by importing from `@spartan-ng/brain/tabs`.

package/tabs/index.d.ts

@@ -0,0 +1,14 @@
+import { BrnTabsListDirective } from './lib/brn-tabs-list.directive';
+import { BrnTabsContentDirective, BrnTabsDirective, BrnTabsTriggerDirective } from './lib/brn-tabs-trigger.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./lib/brn-tabs-trigger.directive";
+import * as i2 from "./lib/brn-tabs-list.directive";
+export * from './lib/brn-tabs-list.directive';
+export * from './lib/brn-tabs-paginated-list.directive';
+export * from './lib/brn-tabs-trigger.directive';
+export declare const BrnTabsImports: readonly [typeof BrnTabsDirective, typeof BrnTabsListDirective, typeof BrnTabsTriggerDirective, typeof BrnTabsContentDirective];
+export declare class BrnTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BrnTabsModule, never, [typeof i1.BrnTabsDirective, typeof i2.BrnTabsListDirective, typeof i1.BrnTabsTriggerDirective, typeof i1.BrnTabsContentDirective], [typeof i1.BrnTabsDirective, typeof i2.BrnTabsListDirective, typeof i1.BrnTabsTriggerDirective, typeof i1.BrnTabsContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BrnTabsModule>;
+}

package/tabs/lib/brn-tabs-list.directive.d.ts

@@ -0,0 +1,17 @@
+import { type AfterContentInit } from '@angular/core';
+import { BrnTabsTriggerDirective } from './brn-tabs-trigger.directive';
+import * as i0 from "@angular/core";
+export declare class BrnTabsListDirective implements AfterContentInit {
+    private readonly _root;
+    protected readonly _orientation: import("@angular/core").InputSignal<import("./brn-tabs-trigger.directive").BrnTabsOrientation>;
+    private readonly _direction;
+    private readonly _activeTab;
+    private readonly _tabs;
+    private readonly _elementRef;
+    private readonly _keyDownListener;
+    private _keyManager?;
+    triggers: import("@angular/core").Signal<readonly BrnTabsTriggerDirective[]>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTabsListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnTabsListDirective, "[brnTabsList]", ["brnTabsList"], {}, {}, ["triggers"], never, true, never>;
+}

package/tabs/lib/brn-tabs-paginated-list.directive.d.ts

@@ -0,0 +1,196 @@
+/**
+ * We are building on shoulders of giants here and adapt the implementation provided by the incredible Angular
+ * team: https://github.com/angular/components/blob/main/src/material/tabs/paginated-tab-header.ts
+ * Check them out! Give them a try! Leave a star! Their work is incredible!
+ */
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { type FocusableOption } from '@angular/cdk/a11y';
+import { type Direction } from '@angular/cdk/bidi';
+import { type AfterContentChecked, type AfterContentInit, type AfterViewInit, ChangeDetectorRef, ElementRef, type OnDestroy, Signal } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * The directions that scrolling can go in when the header's tabs exceed the header width. 'After'
+ * will scroll the header towards the end of the tabs list and 'before' will scroll towards the
+ * beginning of the list.
+ */
+export type ScrollDirection = 'after' | 'before';
+/** Item inside a paginated tab header. */
+export type BrnPaginatedTabHeaderItem = FocusableOption & {
+    elementRef: ElementRef;
+};
+/**
+ * Base class for a tab header that supported pagination.
+ * @docs-private
+ */
+export declare abstract class BrnTabsPaginatedListDirective implements AfterContentChecked, AfterContentInit, AfterViewInit, OnDestroy {
+    abstract _items: Signal<ReadonlyArray<BrnPaginatedTabHeaderItem>>;
+    abstract _itemsChanges: Observable<ReadonlyArray<BrnPaginatedTabHeaderItem>>;
+    abstract _tabListContainer: Signal<ElementRef<HTMLElement>>;
+    abstract _tabList: Signal<ElementRef<HTMLElement>>;
+    abstract _tabListInner: Signal<ElementRef<HTMLElement>>;
+    abstract _nextPaginator: Signal<ElementRef<HTMLElement>>;
+    abstract _previousPaginator: Signal<ElementRef<HTMLElement>>;
+    /** The distance in pixels that the tab labels should be translated to the left. */
+    private _scrollDistance;
+    /** Whether the header should scroll to the selected index after the view has been checked. */
+    private _selectedIndexChanged;
+    private readonly _root;
+    private readonly _activeTab;
+    private readonly _tabs;
+    /** Emits when the component is destroyed. */
+    protected readonly _destroyed: Subject<void>;
+    /** Whether the controls for pagination should be displayed */
+    _showPaginationControls: import("@angular/core").WritableSignal<boolean>;
+    /** Whether the tab list can be scrolled more towards the end of the tab label list. */
+    _disableScrollAfter: boolean;
+    /** Whether the tab list can be scrolled more towards the beginning of the tab label list. */
+    _disableScrollBefore: boolean;
+    /**
+     * The number of tab labels that are displayed on the header. When this changes, the header
+     * should re-evaluate the scroll position.
+     */
+    private _tabLabelCount;
+    /** Whether the scroll distance has changed and should be applied after the view is checked. */
+    private _scrollDistanceChanged;
+    /** Used to manage focus between the tabs. */
+    private _keyManager;
+    /** Cached text content of the header. */
+    private _currentTextContent;
+    /** Stream that will stop the automated scrolling. */
+    private readonly _stopScrolling;
+    /**
+     * Whether pagination should be disabled. This can be used to avoid unnecessary
+     * layout recalculations if it's known that pagination won't be required.
+     */
+    disablePagination: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** The index of the active tab. */
+    private readonly _selectedIndex;
+    /** Event emitted when the option is selected. */
+    readonly selectFocusedIndex: import("@angular/core").OutputEmitterRef<number>;
+    /** Event emitted when a label is focused. */
+    readonly indexFocused: import("@angular/core").OutputEmitterRef<number>;
+    private readonly _sharedResizeObserver;
+    private readonly _injector;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _changeDetectorRef: ChangeDetectorRef;
+    private readonly _viewportRuler;
+    private readonly _dir;
+    private readonly _ngZone;
+    private readonly _platform;
+    _animationMode: "NoopAnimations" | "BrowserAnimations" | null;
+    constructor();
+    /** Called when the user has selected an item via the keyboard. */
+    protected abstract _itemSelected(event: KeyboardEvent): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    /** Sends any changes that could affect the layout of the items. */
+    private _itemsResized;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    /** Handles keyboard events on the header. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Callback for when the MutationObserver detects that the content has changed.
+     */
+    _onContentChanges(): void;
+    /**
+     * Updates the view whether pagination should be enabled or not.
+     *
+     * WARNING: Calling this method can be very costly in terms of performance. It should be called
+     * as infrequently as possible from outside of the Tabs component as it causes a reflow of the
+     * page.
+     */
+    updatePagination(): void;
+    /** Tracks which element has focus; used for keyboard navigation */
+    get focusIndex(): number;
+    /** When the focus index is set, we must manually send focus to the correct label */
+    set focusIndex(value: number);
+    /**
+     * Determines if an index is valid.  If the tabs are not ready yet, we assume that the user is
+     * providing a valid index and return true.
+     */
+    _isValidIndex(index: number): boolean;
+    /**
+     * Sets focus on the HTML element for the label wrapper and scrolls it into the view if
+     * scrolling is enabled.
+     */
+    _setTabFocus(tabIndex: number): void;
+    /** The layout direction of the containing app. */
+    _getLayoutDirection(): Direction;
+    /** Performs the CSS transformation on the tab list that will cause the list to scroll. */
+    _updateTabScrollPosition(): void;
+    /** Sets the distance in pixels that the tab header should be transformed in the X-axis. */
+    get scrollDistance(): number;
+    set scrollDistance(value: number);
+    /**
+     * Moves the tab list in the 'before' or 'after' direction (towards the beginning of the list or
+     * the end of the list, respectively). The distance to scroll is computed to be a third of the
+     * length of the tab list view window.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _scrollHeader(direction: ScrollDirection): {
+        maxScrollDistance: number;
+        distance: number;
+    };
+    /** Handles click events on the pagination arrows. */
+    _handlePaginatorClick(direction: ScrollDirection): void;
+    /**
+     * Moves the tab list such that the desired tab label (marked by index) is moved into view.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _scrollToLabel(labelIndex: number): void;
+    /**
+     * Evaluate whether the pagination controls should be displayed. If the scroll width of the
+     * tab list is wider than the size of the header container, then the pagination controls should
+     * be shown.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _checkPaginationEnabled(): void;
+    /**
+     * Evaluate whether the before and after controls should be enabled or disabled.
+     * If the header is at the beginning of the list (scroll distance is equal to 0) then disable the
+     * before button. If the header is at the end of the list (scroll distance is equal to the
+     * maximum distance we can scroll), then disable the after button.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _checkScrollingControls(): void;
+    /**
+     * Determines what is the maximum length in pixels that can be set for the scroll distance. This
+     * is equal to the difference in width between the tab list container and tab header container.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _getMaxScrollDistance(): number;
+    /** Stops the currently-running paginator interval.  */
+    _stopInterval(): void;
+    /**
+     * Handles the user pressing down on one of the paginators.
+     * Starts scrolling the header after a certain amount of time.
+     * @param direction In which direction the paginator should be scrolled.
+     */
+    _handlePaginatorPress(direction: ScrollDirection, mouseEvent?: MouseEvent): void;
+    /**
+     * Scrolls the header to a given position.
+     * @param position Position to which to scroll.
+     * @returns Information on the current scroll distance and the maximum.
+     */
+    private _scrollTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTabsPaginatedListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnTabsPaginatedListDirective, never, never, { "disablePagination": { "alias": "disablePagination"; "required": false; "isSignal": true; }; }, { "selectFocusedIndex": "selectFocusedIndex"; "indexFocused": "indexFocused"; }, never, never, false, never>;
+}

package/tabs/lib/brn-tabs-trigger.directive.d.ts

@@ -0,0 +1,61 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BrnTabsContentDirective {
+    private readonly _root;
+    private readonly _elementRef;
+    readonly contentFor: import("@angular/core").InputSignal<string>;
+    protected readonly _isSelected: import("@angular/core").Signal<boolean>;
+    protected contentId: import("@angular/core").Signal<string>;
+    protected labelId: import("@angular/core").Signal<string>;
+    constructor();
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTabsContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnTabsContentDirective, "[brnTabsContent]", ["brnTabsContent"], { "contentFor": { "alias": "brnTabsContent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export type BrnTabsOrientation = 'horizontal' | 'vertical';
+export type BrnTabsDirection = 'ltr' | 'rtl';
+export type BrnActivationMode = 'automatic' | 'manual';
+export declare class BrnTabsDirective {
+    readonly orientation: import("@angular/core").InputSignal<BrnTabsOrientation>;
+    /** internal **/
+    $orientation: import("@angular/core").InputSignal<BrnTabsOrientation>;
+    readonly direction: import("@angular/core").InputSignal<BrnTabsDirection>;
+    /** internal **/
+    $direction: import("@angular/core").InputSignal<BrnTabsDirection>;
+    readonly _activeTab: import("@angular/core").ModelSignal<string | undefined>;
+    /** internal **/
+    $activeTab: import("@angular/core").Signal<string | undefined>;
+    readonly activationMode: import("@angular/core").InputSignal<BrnActivationMode>;
+    /** internal **/
+    $activationMode: import("@angular/core").InputSignal<BrnActivationMode>;
+    readonly tabActivated: import("@angular/core").OutputEmitterRef<string>;
+    private readonly _tabs;
+    readonly $tabs: import("@angular/core").Signal<{
+        [key: string]: {
+            trigger: BrnTabsTriggerDirective;
+            content: BrnTabsContentDirective;
+        };
+    }>;
+    registerTrigger(key: string, trigger: BrnTabsTriggerDirective): void;
+    registerContent(key: string, content: BrnTabsContentDirective): void;
+    emitTabActivated(key: string): void;
+    setActiveTab(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTabsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnTabsDirective, "[brnTabs]", ["brnTabs"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "_activeTab": { "alias": "brnTabs"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; }, { "_activeTab": "brnTabsChange"; "tabActivated": "tabActivated"; }, never, never, true, never>;
+}
+export declare class BrnTabsTriggerDirective {
+    readonly elementRef: ElementRef<any>;
+    private readonly _root;
+    protected readonly _orientation: import("@angular/core").InputSignal<BrnTabsOrientation>;
+    readonly triggerFor: import("@angular/core").InputSignal<string>;
+    readonly selected: import("@angular/core").Signal<boolean>;
+    protected readonly contentId: import("@angular/core").Signal<string>;
+    protected readonly labelId: import("@angular/core").Signal<string>;
+    disabled: boolean;
+    constructor();
+    focus(): void;
+    activate(): void;
+    get key(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTabsTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnTabsTriggerDirective, "button[brnTabsTrigger]", ["brnTabsTrigger"], { "triggerFor": { "alias": "brnTabsTrigger"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/toggle/README.md

@@ -0,0 +1,3 @@
+# @spartan-ng/brain/toggle
+
+Secondary entry point of `@spartan-ng/brain`. It can be used by importing from `@spartan-ng/brain/toggle`.

package/toggle/index.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./lib/brn-toggle.directive";
+import * as i2 from "./lib/brn-toggle-group.component";
+export * from './lib/brn-toggle-group.component';
+export * from './lib/brn-toggle.directive';
+export declare class BrnToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BrnToggleModule, never, [typeof i1.BrnToggleDirective], [typeof i1.BrnToggleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BrnToggleModule>;
+}
+export declare class BrnToggleGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnToggleGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BrnToggleGroupModule, never, [typeof i1.BrnToggleDirective, typeof i2.BrnToggleGroupComponent], [typeof i1.BrnToggleDirective, typeof i2.BrnToggleGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BrnToggleGroupModule>;
+}

package/toggle/lib/brn-toggle-group.component.d.ts

@@ -0,0 +1,68 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { type ControlValueAccessor } from '@angular/forms';
+import { BrnToggleDirective } from './brn-toggle.directive';
+import * as i0 from "@angular/core";
+export declare const BRN_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR: {
+    provide: import("@angular/core").InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
+export declare class BrnButtonToggleChange<T = unknown> {
+    source: BrnToggleDirective<T>;
+    value: ToggleValue<T>;
+    constructor(source: BrnToggleDirective<T>, value: ToggleValue<T>);
+}
+export declare class BrnToggleGroupComponent<T = unknown> implements ControlValueAccessor {
+    /**
+     * The method to be called in order to update ngModel.
+     */
+    private _onChange;
+    /** onTouch function registered via registerOnTouch (ControlValueAccessor). */
+    protected onTouched: () => void;
+    /** Whether the button toggle group has a vertical orientation */
+    readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Value of the toggle group. */
+    readonly value: import("@angular/core").ModelSignal<ToggleValue<T>>;
+    /** Whether no button toggles need to be selected. */
+    readonly nullable: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether multiple button toggles can be selected. */
+    readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the button toggle group is disabled. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** The internal state of the component. This can be replaced with linkedSignal in the future. */
+    readonly state: import("@angular/core").Signal<{
+        disabled: import("@angular/core").WritableSignal<boolean>;
+    }>;
+    /** Emit event when the group value changes. */
+    readonly change: import("@angular/core").OutputEmitterRef<BrnButtonToggleChange<T>>;
+    writeValue(value: ToggleValue<T>): void;
+    registerOnChange(fn: (value: ToggleValue<T>) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * @internal
+     * Determines whether a value can be set on the group.
+     */
+    canDeselect(value: ToggleValue<T>): boolean;
+    /**
+     * @internal
+     * Selects a value.
+     */
+    select(value: T, source: BrnToggleDirective<T>): void;
+    /**
+     * @internal
+     * Deselects a value.
+     */
+    deselect(value: T, source: BrnToggleDirective<T>): void;
+    /**
+     * @internal
+     * Determines whether a value is selected.
+     */
+    isSelected(value: T): boolean;
+    /** Update the value of the group */
+    private emitSelectionChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnToggleGroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BrnToggleGroupComponent<any>, "brn-toggle-group", ["brnToggleGroup"], { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "nullable": { "alias": "nullable"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+type ToggleValue<T> = T | T[] | null | undefined;
+export {};

package/toggle/lib/brn-toggle-group.token.d.ts

@@ -0,0 +1,4 @@
+import { ExistingProvider, Type } from '@angular/core';
+import type { BrnToggleGroupComponent } from './brn-toggle-group.component';
+export declare function injectBrnToggleGroup<T>(): BrnToggleGroupComponent<T> | null;
+export declare function provideBrnToggleGroup<T>(value: Type<BrnToggleGroupComponent<T>>): ExistingProvider;

package/toggle/lib/brn-toggle.directive.d.ts

@@ -0,0 +1,25 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class BrnToggleDirective<T> {
+    private static _uniqueId;
+    private readonly _changeDetector;
+    /** Access the toggle group if available. */
+    protected readonly group: import("@spartan-ng/brain/toggle").BrnToggleGroupComponent<T> | null;
+    /** The id of the toggle. */
+    readonly id: import("@angular/core").InputSignal<string>;
+    /** The value this toggle represents. */
+    readonly value: import("@angular/core").InputSignal<T | undefined>;
+    /** Whether the toggle is disabled. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** The current state of the toggle when not used in a group. */
+    readonly state: import("@angular/core").ModelSignal<"on" | "off">;
+    /** Whether the toggle is responds to click events. */
+    readonly disableToggleClick: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the toggle is in the on state. */
+    protected readonly isOn: import("@angular/core").Signal<boolean>;
+    /** The current state that reflects the group state or the model state. */
+    protected readonly _state: import("@angular/core").Signal<"on" | "off">;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnToggleDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrnToggleDirective<any>, "button[hlmToggle], button[brnToggle]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "disableToggleClick": { "alias": "disableToggleClick"; "required": false; "isSignal": true; }; }, { "state": "stateChange"; }, never, never, true, never>;
+}

package/tooltip/README.md

@@ -0,0 +1,3 @@
+# @spartan-ng/brain/tooltip
+
+Secondary entry point of `@spartan-ng/brain`. It can be used by importing from `@spartan-ng/brain/tooltip`.

package/tooltip/index.d.ts

@@ -0,0 +1,19 @@
+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";
+import * as i1 from "./lib/brn-tooltip.directive";
+import * as i2 from "./lib/brn-tooltip-content.directive";
+import * as i3 from "./lib/brn-tooltip-trigger.directive";
+import * as i4 from "./lib/brn-tooltip-content.component";
+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 declare const BrnTooltipImports: readonly [typeof BrnTooltipDirective, typeof BrnTooltipContentDirective, typeof BrnTooltipTriggerDirective, typeof BrnTooltipContentComponent];
+export declare class BrnTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrnTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BrnTooltipModule, never, [typeof i1.BrnTooltipDirective, typeof i2.BrnTooltipContentDirective, typeof i3.BrnTooltipTriggerDirective, typeof i4.BrnTooltipContentComponent], [typeof i1.BrnTooltipDirective, typeof i2.BrnTooltipContentDirective, typeof i3.BrnTooltipTriggerDirective, typeof i4.BrnTooltipContentComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BrnTooltipModule>;
+}