@spartan-ng/brain 0.0.1-alpha.563 → 0.0.1-alpha.564

package/collapsible/index.d.ts

@@ -1,8 +1,70 @@
-import { BrnCollapsible } from './lib/brn-collapsible';
-import { BrnCollapsibleContent } from './lib/brn-collapsible-content';
-import { BrnCollapsibleTrigger } from './lib/brn-collapsible-trigger';
-export * from './lib/brn-collapsible';
-export * from './lib/brn-collapsible-content';
-export * from './lib/brn-collapsible-token';
-export * from './lib/brn-collapsible-trigger';
-export declare const BrnCollapsibleImports: readonly [typeof BrnCollapsible, typeof BrnCollapsibleTrigger, typeof BrnCollapsibleContent];
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Type, ExistingProvider, ValueProvider } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as _spartan_ng_brain_collapsible from '@spartan-ng/brain/collapsible';
+import { MeasurementDisplay } from '@spartan-ng/brain/core';
+
+type BrnCollapsibleState = 'open' | 'closed';
+declare class BrnCollapsible {
+    readonly contentId: _angular_core.WritableSignal<string>;
+    /**
+     * The expanded or collapsed state of the collapsible component.
+     */
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    /**
+     * The current state of the collapsible component as 'open' or 'closed'.
+     */
+    readonly state: _angular_core.Signal<BrnCollapsibleState>;
+    /**
+     * The disabled state of the collapsible component.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Toggles the expanded state of the collapsible component.
+     */
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCollapsible, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCollapsible, "[brnCollapsible],brn-collapsible", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, never, true, never>;
+}
+
+declare class BrnCollapsibleContent {
+    private readonly _config;
+    private readonly _elementRef;
+    protected readonly _collapsible: _spartan_ng_brain_collapsible.BrnCollapsible | null;
+    protected readonly _width: _angular_core.WritableSignal<number | null>;
+    protected readonly _height: _angular_core.WritableSignal<number | null>;
+    /**
+     * The id of the collapsible content element.
+     */
+    readonly id: _angular_core.InputSignal<string | null | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCollapsibleContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCollapsibleContent, "[brnCollapsibleContent],brn-collapsible-content", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BrnCollapsibleTrigger {
+    protected readonly _collapsible: _spartan_ng_brain_collapsible.BrnCollapsible | null;
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    constructor();
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCollapsibleTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCollapsibleTrigger, "button[brnCollapsibleTrigger]", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const BrnCollapsibleToken: InjectionToken<BrnCollapsible>;
+declare function injectBrnCollapsible(): BrnCollapsible | null;
+declare function provideBrnCollapsible(collapsible: Type<BrnCollapsible>): ExistingProvider;
+interface BrCollapsibleConfig {
+    /**
+     * The display style to use when measuring element dimensions.
+     * @default 'block'
+     */
+    measurementDisplay: MeasurementDisplay;
+}
+declare function provideBrnCollapsibleConfig(config: Partial<BrCollapsibleConfig>): ValueProvider;
+declare function injectBrnCollapsibleConfig(): BrCollapsibleConfig;
+
+declare const BrnCollapsibleImports: readonly [typeof BrnCollapsible, typeof BrnCollapsibleTrigger, typeof BrnCollapsibleContent];
+
+export { BrnCollapsible, BrnCollapsibleContent, BrnCollapsibleImports, BrnCollapsibleToken, BrnCollapsibleTrigger, injectBrnCollapsible, injectBrnCollapsibleConfig, provideBrnCollapsible, provideBrnCollapsibleConfig };
+export type { BrCollapsibleConfig, BrnCollapsibleState };

package/command/index.d.ts

@@ -1,16 +1,147 @@
-import { BrnCommand } from './lib/brn-command';
-import { BrnCommandEmpty } from './lib/brn-command-empty';
-import { BrnCommandGroup } from './lib/brn-command-group';
-import { BrnCommandItem } from './lib/brn-command-item';
-import { BrnCommandList } from './lib/brn-command-list';
-import { BrnCommandSearchInput } from './lib/brn-command-search-input';
-export * from './lib/brn-command';
-export * from './lib/brn-command-empty';
-export * from './lib/brn-command-group';
-export * from './lib/brn-command-item';
-export * from './lib/brn-command-item.token';
-export * from './lib/brn-command-list';
-export * from './lib/brn-command-search-input';
-export * from './lib/brn-command-search-input.token';
-export * from './lib/brn-command.token';
-export declare const BrnCommandImports: readonly [typeof BrnCommandEmpty, typeof BrnCommandGroup, typeof BrnCommandItem, typeof BrnCommandList, typeof BrnCommandSearchInput, typeof BrnCommand];
+import * as _spartan_ng_brain_command from '@spartan-ng/brain/command';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Type, ExistingProvider, ValueProvider, AfterViewInit, OnInit } from '@angular/core';
+import { ActiveDescendantKeyManager, Highlightable } from '@angular/cdk/a11y';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { DefaultValueAccessor } from '@angular/forms';
+
+declare const BrnCommandToken: InjectionToken<BrnCommand>;
+declare function provideBrnCommand(command: Type<BrnCommand>): ExistingProvider;
+declare function injectBrnCommand(): BrnCommand;
+type CommandFilter = (value: string, search: string) => boolean;
+interface BrnCommandConfig {
+    filter: CommandFilter;
+}
+declare function provideBrnCommandConfig(config: Partial<BrnCommandConfig>): ValueProvider;
+declare function injectBrnCommandConfig(): BrnCommandConfig;
+
+declare class BrnCommand implements AfterViewInit {
+    private static _id;
+    private readonly _platform;
+    private readonly _injector;
+    private readonly _config;
+    /** The id of the command */
+    readonly id: _angular_core.InputSignal<string>;
+    /** A custom filter function to use when searching. */
+    readonly filter: _angular_core.InputSignal<CommandFilter>;
+    /** when the selection has changed */
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    /** @internal The search query */
+    readonly search: _angular_core.Signal<string>;
+    /** Access the search input if present */
+    private readonly _searchInput;
+    /** @internal Access all the items within the command */
+    readonly items: _angular_core.Signal<readonly _spartan_ng_brain_command.BrnCommandItem[]>;
+    /** @internal The key manager for managing active descendant */
+    readonly keyManager: ActiveDescendantKeyManager<_spartan_ng_brain_command.BrnCommandItem>;
+    constructor();
+    ngAfterViewInit(): void;
+    protected selectActiveItem(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCommand, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCommand, "[brnCommand]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, ["_searchInput", "items"], never, true, never>;
+}
+
+declare class BrnCommandEmpty {
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private readonly _command;
+    /** Determine if the command has any visible items */
+    private readonly _visible;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCommandEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCommandEmpty, "[brnCommandEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BrnCommandGroup {
+    private static _id;
+    /** The id of the command list */
+    readonly id: _angular_core.InputSignal<string>;
+    /** Get the items in the group */
+    private readonly _items;
+    /** Determine if there are any visible items in the group */
+    protected readonly _visible: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCommandGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCommandGroup, "[brnCommandGroup]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, ["_items"], never, true, never>;
+}
+
+declare class BrnCommandItem implements Highlightable, OnInit {
+    private static _id;
+    private readonly _platform;
+    private readonly _elementRef;
+    /** Access the command component */
+    private readonly _command;
+    /** A unique id for the item */
+    readonly id: _angular_core.InputSignal<string>;
+    /** The value this item represents. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Whether the item is disabled. */
+    readonly _disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Expose disabled as a value - used by the Highlightable interface */
+    get disabled(): boolean;
+    /** Whether the item is initialized, this is to prevent accessing the value-input before the component is initialized.
+     * The brn-command-empty directive accesses the value before the component is initialized, which causes an error.
+     */
+    private readonly _initialized;
+    /** Whether the item is selected. */
+    protected readonly _active: _angular_core.WritableSignal<boolean>;
+    /** Emits when the item is selected. */
+    readonly selected: _angular_core.OutputEmitterRef<void>;
+    /** @internal Determine if this item is visible based on the current search query */
+    readonly visible: _angular_core.Signal<boolean>;
+    /** @internal Get the value of the item, with check if it has been initialized to avoid errors */
+    readonly safeValue: _angular_core.Signal<string>;
+    /** @internal Get the display value */
+    getLabel(): string;
+    /** @internal */
+    setActiveStyles(): void;
+    /** @internal */
+    setInactiveStyles(): void;
+    protected onClick(): void;
+    protected activate(): void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCommandItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCommandItem, "button[brnCommandItem]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+
+declare class BrnCommandList {
+    private static _id;
+    /** The id of the command list */
+    readonly id: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCommandList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCommandList, "[brnCommandList]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BrnCommandSearchInput extends DefaultValueAccessor implements OnInit {
+    private readonly _destroyRef;
+    private readonly _el;
+    private readonly _injector;
+    private readonly _command;
+    /** The initial value of the search input */
+    readonly value: _angular_core.InputSignal<string>;
+    /** @internal The mutable value of the search input */
+    readonly mutableValue: _angular_core.Signal<_angular_core.WritableSignal<string>>;
+    /** @internal The "real" value of the search input */
+    readonly valueState: _angular_core.Signal<string>;
+    /** The id of the active option */
+    protected readonly _activeDescendant: _angular_core.WritableSignal<string | undefined>;
+    ngOnInit(): void;
+    /** Listen for changes to the input value */
+    protected onInput(): void;
+    /** Listen for keydown events */
+    protected onKeyDown(event: KeyboardEvent): void;
+    /** CONROL VALUE ACCESSOR */
+    writeValue(value: string | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrnCommandSearchInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BrnCommandSearchInput, "input[brnCommandSearchInput]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const BrnCommandItemToken: InjectionToken<BrnCommandItem>;
+declare function provideBrnCommandItem(command: Type<BrnCommandItem>): ExistingProvider;
+
+declare const BrnCommandSearchInputToken: InjectionToken<BrnCommandSearchInput>;
+declare function provideBrnCommandSearchInput(command: Type<BrnCommandSearchInput>): ExistingProvider;
+
+declare const BrnCommandImports: readonly [typeof BrnCommandEmpty, typeof BrnCommandGroup, typeof BrnCommandItem, typeof BrnCommandList, typeof BrnCommandSearchInput, typeof BrnCommand];
+
+export { BrnCommand, BrnCommandEmpty, BrnCommandGroup, BrnCommandImports, BrnCommandItem, BrnCommandItemToken, BrnCommandList, BrnCommandSearchInput, BrnCommandSearchInputToken, BrnCommandToken, injectBrnCommand, injectBrnCommandConfig, provideBrnCommand, provideBrnCommandConfig, provideBrnCommandItem, provideBrnCommandSearchInput };
+export type { BrnCommandConfig, CommandFilter };

package/core/index.d.ts

@@ -1,11 +1,153 @@
-export * from './helpers/computed-previous';
-export * from './helpers/create-hover-observable';
-export * from './helpers/custom-element-class-settable';
-export * from './helpers/debounced-signal';
-export * from './helpers/dev-mode';
-export * from './helpers/exposes-side';
-export * from './helpers/exposes-state';
-export * from './helpers/measure-dimensions';
-export * from './helpers/table-classes-settable';
-export * from './helpers/wait-for-element-animations';
-export * from './helpers/zone-free';
+import * as _angular_core from '@angular/core';
+import { Signal, NgZone } from '@angular/core';
+import { Subject, Observable, MonoTypeOperatorFunction } from 'rxjs';
+
+/**
+ * Returns a signal that emits the previous value of the given signal.
+ * The first time the signal is emitted, the previous value will be the same as the current value.
+ *
+ * @example
+ * ```ts
+ * const value = signal(0);
+ * const previous = computedPrevious(value);
+ *
+ * effect(() => {
+ *  console.log('Current value:', value());
+ *  console.log('Previous value:', previous());
+ * });
+ *
+ * Logs:
+ * // Current value: 0
+ * // Previous value: 0
+ *
+ * value.set(1);
+ *
+ * Logs:
+ * // Current value: 1
+ * // Previous value: 0
+ *
+ * value.set(2);
+ *
+ * Logs:
+ * // Current value: 2
+ * // Previous value: 1
+ *```
+ *
+ * @param computation Signal to compute previous value for
+ * @returns Signal that emits previous value of `s`
+ */
+declare function computedPrevious<T>(computation: Signal<T>): Signal<T>;
+
+declare function isElement(node?: Element | EventTarget | Node | null): node is Element;
+declare const createHoverObservable: (nativeElement: HTMLElement, zone: NgZone, destroyed$: Subject<void>) => Observable<{
+    hover: boolean;
+    relatedTarget?: EventTarget | null;
+}>;
+
+interface CustomElementClassSettable {
+    setClassToCustomElement: (newClass: string) => void;
+}
+declare const injectCustomClassSettable: {
+    (): CustomElementClassSettable;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional?: false;
+    }): CustomElementClassSettable;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional: true;
+    }): CustomElementClassSettable | null;
+};
+declare const provideCustomClassSettable: (value: CustomElementClassSettable) => _angular_core.Provider;
+declare const provideCustomClassSettableExisting: (valueFactory: () => _angular_core.Type<CustomElementClassSettable>) => _angular_core.Provider;
+declare const SET_CLASS_TO_CUSTOM_ELEMENT_TOKEN: _angular_core.InjectionToken<CustomElementClassSettable>;
+
+/**
+ * Creates a debounced version of a source signal.
+ *
+ * @param source - The input signal to debounce.
+ * @param delay - Debounce time in milliseconds.
+ * @returns A new signal that updates only after the source has stopped changing for `delay` ms.
+ */
+declare function debouncedSignal<T>(source: Signal<T>, delay: number): Signal<T>;
+
+/**
+ * Set by Angular to true when in development mode.
+ * Allows for tree-shaking code that is only used in development.
+ */
+declare const brnDevMode: boolean;
+
+interface ExposesSide {
+    side: Signal<'top' | 'bottom' | 'left' | 'right'>;
+}
+declare const injectExposedSideProvider: {
+    (): ExposesSide;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional?: false;
+    }): ExposesSide;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional: true;
+    }): ExposesSide | null;
+};
+declare const provideExposedSideProvider: (value: ExposesSide) => _angular_core.Provider;
+declare const provideExposedSideProviderExisting: (valueFactory: () => _angular_core.Type<ExposesSide>) => _angular_core.Provider;
+declare const EXPOSES_SIDE_TOKEN: _angular_core.InjectionToken<ExposesSide>;
+
+interface ExposesState {
+    state: Signal<'open' | 'closed'>;
+}
+declare const injectExposesStateProvider: {
+    (): ExposesState;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional?: false;
+    }): ExposesState;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional: true;
+    }): ExposesState | null;
+};
+declare const provideExposesStateProvider: (value: ExposesState) => _angular_core.Provider;
+declare const provideExposesStateProviderExisting: (valueFactory: () => _angular_core.Type<ExposesState>) => _angular_core.Provider;
+declare const EXPOSES_STATE_TOKEN: _angular_core.InjectionToken<ExposesState>;
+
+type MeasurementDisplay = 'block' | 'inline-block' | 'flex' | 'grid' | 'table' | 'contents' | (string & {});
+declare const measureDimensions: (elementToMeasure: HTMLElement, measurementDisplay: MeasurementDisplay) => {
+    width: number;
+    height: number;
+};
+
+interface TableClassesSettable {
+    setTableClasses: (classes: Partial<{
+        table: string;
+        headerRow: string;
+        bodyRow: string;
+    }>) => void;
+}
+declare const injectTableClassesSettable: {
+    (): TableClassesSettable;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional?: false;
+    }): TableClassesSettable;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional: true;
+    }): TableClassesSettable | null;
+};
+declare const provideTableClassesSettable: (value: TableClassesSettable) => _angular_core.Provider;
+declare const provideTableClassesSettableExisting: (valueFactory: () => _angular_core.Type<TableClassesSettable>) => _angular_core.Provider;
+declare const SET_TABLE_CLASSES_TOKEN: _angular_core.InjectionToken<TableClassesSettable>;
+
+/**
+ * Waits for all animations (including subtree) within the given element to finish.
+ * Ignores animations canceled with an AbortError.
+ */
+declare function waitForElementAnimations(el: HTMLElement): Promise<void>;
+
+/**
+ * We are building on shoulders of giants here and use the implementation provided by the incredible TaigaUI
+ * team: https://github.com/taiga-family/taiga-ui/blob/main/projects/cdk/observables/zone-free.ts#L22
+ * Check them out! Give them a try! Leave a star! Their work is incredible!
+ */
+
+declare function brnZoneFull<T>(zone: NgZone): MonoTypeOperatorFunction<T>;
+declare function brnZoneFree<T>(zone: NgZone): MonoTypeOperatorFunction<T>;
+declare function brnZoneOptimized<T>(zone: NgZone): MonoTypeOperatorFunction<T>;
+
+export { EXPOSES_SIDE_TOKEN, EXPOSES_STATE_TOKEN, SET_CLASS_TO_CUSTOM_ELEMENT_TOKEN, SET_TABLE_CLASSES_TOKEN, brnDevMode, brnZoneFree, brnZoneFull, brnZoneOptimized, computedPrevious, createHoverObservable, debouncedSignal, injectCustomClassSettable, injectExposedSideProvider, injectExposesStateProvider, injectTableClassesSettable, isElement, measureDimensions, provideCustomClassSettable, provideCustomClassSettableExisting, provideExposedSideProvider, provideExposedSideProviderExisting, provideExposesStateProvider, provideExposesStateProviderExisting, provideTableClassesSettable, provideTableClassesSettableExisting, waitForElementAnimations };
+export type { CustomElementClassSettable, ExposesSide, ExposesState, MeasurementDisplay, TableClassesSettable };