ng-primitives 0.89.0 → 0.90.0

package/toggle-group/index.d.ts

@@ -1,5 +1,143 @@
-export { NgpToggleGroupConfig, provideToggleGroupConfig } from './config/toggle-group-config';
-export { NgpToggleGroupItem } from './toggle-group-item/toggle-group-item';
-export { injectToggleGroupItemState, provideToggleGroupItemState, } from './toggle-group-item/toggle-group-item-state';
-export { NgpToggleGroup } from './toggle-group/toggle-group';
-export { injectToggleGroupState, provideToggleGroupState } from './toggle-group/toggle-group-state';
+import * as _angular_core from '@angular/core';
+import { Provider, OnInit } from '@angular/core';
+import { NgpOrientation } from 'ng-primitives/common';
+import * as ng_primitives_state from 'ng-primitives/state';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from 'ng-primitives/roving-focus';
+
+interface NgpToggleGroupConfig {
+    /**
+     * The orientation of the toggle group.
+     * @default 'horizontal'
+     */
+    orientation: NgpOrientation;
+    /**
+     * The type of the toggle group, whether only one item can be selected or multiple.
+     * @default 'single'
+     */
+    type: 'single' | 'multiple';
+    /**
+     * Whether a toggle button can be deselected.
+     * @default true
+     */
+    allowDeselection: boolean;
+}
+/**
+ * Provide the default ToggleGroup configuration
+ * @param config The ToggleGroup configuration
+ * @returns The provider
+ */
+declare function provideToggleGroupConfig(config: Partial<NgpToggleGroupConfig>): Provider[];
+
+declare class NgpToggleGroupItem implements OnInit {
+    /**
+     * Access the group that the item belongs to.
+     */
+    private readonly toggleGroup;
+    /**
+     * The value of the item.
+     * @required
+     */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the item is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the item is selected.
+     */
+    protected readonly selected: _angular_core.Signal<boolean>;
+    /**
+     * The state of the item.
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpToggleGroupItem>;
+    ngOnInit(): void;
+    /**
+     * Toggle the item.
+     */
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpToggleGroupItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpToggleGroupItem, "[ngpToggleGroupItem]", ["ngpToggleGroupItem"], { "value": { "alias": "ngpToggleGroupItemValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpToggleGroupItemDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpRovingFocusItem; inputs: { "ngpRovingFocusItemDisabled": "ngpToggleGroupItemDisabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * Provides the ToggleGroupItem state.
+ */
+declare const provideToggleGroupItemState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the ToggleGroupItem state.
+ */
+declare const injectToggleGroupItemState: <U = NgpToggleGroupItem>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+declare class NgpToggleGroup {
+    /**
+     * Access the roving focus group state.
+     */
+    private readonly rovingFocusGroupState;
+    /**
+     * Access the global toggle group configuration.
+     */
+    private readonly config;
+    /**
+     * The orientation of the toggle group.
+     */
+    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
+    /**
+     * Whether toggle buttons can be deselected. If set to `false`, clicking a selected toggle button will not deselect it.
+     * @default true
+     */
+    readonly allowDeselection: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The type of the toggle group, whether only one item can be selected or multiple.
+     */
+    readonly type: _angular_core.InputSignal<"single" | "multiple">;
+    /**
+     * The selected value(s) of the toggle group.
+     */
+    readonly value: _angular_core.InputSignal<string[]>;
+    /**
+     * Emits when the value of the toggle group changes.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<string[]>;
+    /**
+     * Whether the toggle group is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The state of the toggle group.
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpToggleGroup>;
+    constructor();
+    /**
+     * Select a value in the toggle group.
+     */
+    private select;
+    /**
+     * De-select a value in the toggle group.
+     */
+    private deselect;
+    /**
+     * Check if a value is selected in the toggle group.
+     * @internal
+     */
+    isSelected(value: string): boolean;
+    /**
+     * Toggle a value in the toggle group.
+     * @internal
+     */
+    toggle(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpToggleGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpToggleGroup, "[ngpToggleGroup]", ["ngpToggleGroup"], { "orientation": { "alias": "ngpToggleGroupOrientation"; "required": false; "isSignal": true; }; "allowDeselection": { "alias": "ngpToggleGroupAllowDeselection"; "required": false; "isSignal": true; }; "type": { "alias": "ngpToggleGroupType"; "required": false; "isSignal": true; }; "value": { "alias": "ngpToggleGroupValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpToggleGroupDisabled"; "required": false; "isSignal": true; }; }, { "valueChange": "ngpToggleGroupValueChange"; }, never, never, true, [{ directive: typeof i1.NgpRovingFocusGroup; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Provides the ToggleGroup state.
+ */
+declare const provideToggleGroupState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the ToggleGroup state.
+ */
+declare const injectToggleGroupState: <U = NgpToggleGroup>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpToggleGroup, NgpToggleGroupItem, injectToggleGroupItemState, injectToggleGroupState, provideToggleGroupConfig, provideToggleGroupItemState, provideToggleGroupState };
+export type { NgpToggleGroupConfig };

package/toolbar/index.d.ts

@@ -1,2 +1,33 @@
-export { NgpToolbar } from './toolbar/toolbar';
-export { provideToolbarState, injectToolbarState } from './toolbar/toolbar-state';
+import * as ng_primitives_state from 'ng-primitives/state';
+import * as _angular_core from '@angular/core';
+import { NgpOrientation } from 'ng-primitives/common';
+import * as i1 from 'ng-primitives/roving-focus';
+
+declare class NgpToolbar {
+    /**
+     * Access the roving focus group state.
+     */
+    private readonly rovingFocusGroup;
+    /**
+     * The orientation of the toolbar.
+     */
+    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
+    /**
+     * The toolbar state.
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpToolbar>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpToolbar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpToolbar, "[ngpToolbar]", ["ngpToolbar"], { "orientation": { "alias": "ngpToolbarOrientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpRovingFocusGroup; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Provides the Toolbar state.
+ */
+declare const provideToolbarState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the Toolbar state.
+ */
+declare const injectToolbarState: <U = NgpToolbar>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpToolbar, injectToolbarState, provideToolbarState };

package/tooltip/index.d.ts

@@ -1,6 +1,215 @@
+import * as ng_primitives_portal from 'ng-primitives/portal';
+import { NgpOffset, NgpOverlayContent, NgpOffsetInput, NgpOverlay } from 'ng-primitives/portal';
 export { injectOverlayContext as injectTooltipContext } from 'ng-primitives/portal';
-export { NgpTooltipConfig, provideTooltipConfig } from './config/tooltip-config';
-export { NgpTooltipArrow } from './tooltip-arrow/tooltip-arrow';
-export { NgpTooltipTrigger, type NgpTooltipPlacement } from './tooltip-trigger/tooltip-trigger';
-export { injectTooltipTriggerState, provideTooltipTriggerState, } from './tooltip-trigger/tooltip-trigger-state';
-export { NgpTooltip } from './tooltip/tooltip';
+import * as _angular_core from '@angular/core';
+import { Provider, OnDestroy, Signal } from '@angular/core';
+import { Placement } from '@floating-ui/dom';
+import * as ng_primitives_state from 'ng-primitives/state';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+
+interface NgpTooltipConfig {
+    /**
+     * Define the offset of the tooltip relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 4
+     */
+    offset: NgpOffset;
+    /**
+     * Define the placement of the tooltip relative to the trigger.
+     * @default 'top'
+     */
+    placement: Placement;
+    /**
+     * Define the delay before the tooltip is shown.
+     * @default 0
+     */
+    showDelay: number;
+    /**
+     * Define the delay before the tooltip is hidden.
+     * @default 500
+     */
+    hideDelay: number;
+    /**
+     * Define whether the tooltip should flip when there is not enough space for the tooltip.
+     * @default true
+     */
+    flip: boolean;
+    /**
+     * Define the container element or selector in to which the tooltip should be attached.
+     * @default 'body'
+     */
+    container: HTMLElement | string | null;
+    /**
+     * Whether the tooltip should only show when the trigger element overflows.
+     * @default false
+     */
+    showOnOverflow: boolean;
+    /**
+     * Whether to use the text content of the trigger element as the tooltip content.
+     * @default true
+     */
+    useTextContent: boolean;
+}
+/**
+ * Provide the default Tooltip configuration
+ * @param config The Tooltip configuration
+ * @returns The provider
+ */
+declare function provideTooltipConfig(config: Partial<NgpTooltipConfig>): Provider[];
+
+declare class NgpTooltipArrow {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpTooltipArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpTooltipArrow, "[ngpTooltipArrow]", ["ngpTooltipArrow"], {}, {}, never, never, true, never>;
+}
+
+type TooltipInput<T> = NgpOverlayContent<T> | string | null | undefined;
+/**
+ * Apply the `ngpTooltipTrigger` directive to an element that triggers the tooltip to show.
+ */
+declare class NgpTooltipTrigger<T = null> implements OnDestroy {
+    /**
+     * Access the trigger element
+     */
+    private readonly trigger;
+    /**
+     * Access the injector.
+     */
+    private readonly injector;
+    /**
+     * Access the view container reference.
+     */
+    private readonly viewContainerRef;
+    /**
+     * Access the global tooltip configuration.
+     */
+    private readonly config;
+    /**
+     * Access the tooltip template ref.
+     */
+    readonly tooltip: _angular_core.InputSignalWithTransform<string | NgpOverlayContent<T> | null, TooltipInput<T>>;
+    /**
+     * Define if the trigger should be disabled.
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Define the placement of the tooltip relative to the trigger.
+     * @default 'top'
+     */
+    readonly placement: _angular_core.InputSignal<NgpTooltipPlacement>;
+    /**
+     * Define the offset of the tooltip relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 0
+     */
+    readonly offset: _angular_core.InputSignalWithTransform<NgpOffset, NgpOffsetInput>;
+    /**
+     * Define the delay before the tooltip is displayed.
+     * @default 500
+     */
+    readonly showDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Define the delay before the tooltip is hidden.
+     * @default 0
+     */
+    readonly hideDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Define whether the tooltip should flip when there is not enough space for the tooltip.
+     * @default true
+     */
+    readonly flip: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Define the container in which the tooltip should be attached.
+     * @default document.body
+     */
+    readonly container: _angular_core.InputSignal<string | HTMLElement | null>;
+    /**
+     * Define whether the tooltip should only show when the trigger element overflows.
+     * @default false
+     */
+    readonly showOnOverflow: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Provide context to the tooltip. This can be used to pass data to the tooltip content.
+     */
+    readonly context: _angular_core.InputSignal<T | undefined>;
+    /**
+     * Define whether to use the text content of the trigger element as the tooltip content.
+     * When enabled, the tooltip will display the text content of the trigger element.
+     * @default true
+     */
+    readonly useTextContent: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The overlay that manages the tooltip
+     * @internal
+     */
+    readonly overlay: _angular_core.WritableSignal<NgpOverlay<string | T> | null>;
+    /**
+     * The unique id of the tooltip.
+     */
+    readonly tooltipId: _angular_core.WritableSignal<string | undefined>;
+    /**
+     * The open state of the tooltip.
+     * @internal
+     */
+    readonly open: Signal<boolean>;
+    /**
+     * Determine if the trigger element has overflow.
+     */
+    private readonly hasOverflow;
+    /**
+     * Store the state of the tooltip.
+     * @internal
+     */
+    readonly state: ng_primitives_state.CreatedState<NgpTooltipTrigger<T>>;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Show the tooltip.
+     */
+    show(): void;
+    /**
+     * Hide the tooltip.
+     */
+    hide(): void;
+    /**
+     * Create the overlay that will contain the tooltip
+     */
+    private createOverlay;
+    /**
+     * Set the tooltip id.
+     */
+    setTooltipId(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpTooltipTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpTooltipTrigger<any>, "[ngpTooltipTrigger]", ["ngpTooltipTrigger"], { "tooltip": { "alias": "ngpTooltipTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpTooltipTriggerDisabled"; "required": false; "isSignal": true; }; "placement": { "alias": "ngpTooltipTriggerPlacement"; "required": false; "isSignal": true; }; "offset": { "alias": "ngpTooltipTriggerOffset"; "required": false; "isSignal": true; }; "showDelay": { "alias": "ngpTooltipTriggerShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "ngpTooltipTriggerHideDelay"; "required": false; "isSignal": true; }; "flip": { "alias": "ngpTooltipTriggerFlip"; "required": false; "isSignal": true; }; "container": { "alias": "ngpTooltipTriggerContainer"; "required": false; "isSignal": true; }; "showOnOverflow": { "alias": "ngpTooltipTriggerShowOnOverflow"; "required": false; "isSignal": true; }; "context": { "alias": "ngpTooltipTriggerContext"; "required": false; "isSignal": true; }; "useTextContent": { "alias": "ngpTooltipTriggerUseTextContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type NgpTooltipPlacement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+
+/**
+ * Provides the TooltipTrigger state.
+ */
+declare const provideTooltipTriggerState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the TooltipTrigger state.
+ */
+declare const injectTooltipTriggerState: <U = NgpTooltipTrigger<unknown>>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Apply the `ngpTooltip` directive to an element that represents the tooltip. This typically would be a `div` inside an `ng-template`.
+ */
+declare class NgpTooltip {
+    /**
+     * Access the overlay.
+     */
+    protected readonly overlay: ng_primitives_portal.NgpOverlay<unknown>;
+    /**
+     * The unique id of the tooltip.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpTooltip, "[ngpTooltip]", ["ngpTooltip"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgpTooltip, NgpTooltipArrow, NgpTooltipTrigger, injectTooltipTriggerState, provideTooltipConfig, provideTooltipTriggerState };
+export type { NgpTooltipConfig, NgpTooltipPlacement };

package/utils/index.d.ts

@@ -1,9 +1,169 @@
-export { provideValueAccessor } from './forms/providers';
-export { controlStatus, NgpControlStatus } from './forms/status';
-export { ChangeFn, TouchedFn } from './forms/types';
-export { booleanAttributeBinding } from './helpers/attributes';
-export { injectDisposables } from './helpers/disposables';
-export { uniqueId } from './helpers/unique-id';
-export { isBoolean, isFunction, isNumber, isObject, isString, isUndefined, isNil, notNil, } from './helpers/validators';
-export { safeTakeUntilDestroyed } from './observables/take-until-destroyed';
-export { onBooleanChange, onChange } from './signals';
+import { Type, ExistingProvider, Signal, DestroyRef, Injector } from '@angular/core';
+import { MonoTypeOperatorFunction } from 'rxjs';
+
+/**
+ * A simple helper function to provide a value accessor for a given type.
+ * @param type The type to provide the value accessor for
+ */
+declare function provideValueAccessor<T>(type: Type<T>): ExistingProvider;
+
+interface NgpControlStatus {
+    valid: boolean | null;
+    invalid: boolean | null;
+    pristine: boolean | null;
+    dirty: boolean | null;
+    touched: boolean | null;
+    pending: boolean | null;
+    disabled: boolean | null;
+}
+/**
+ * A utility function to get the status of an Angular form control as a reactive signal.
+ * This function injects the NgControl and returns a signal that reflects the control's status.
+ * @internal
+ */
+declare function controlStatus(): Signal<NgpControlStatus>;
+
+/**
+ * A utility type for Angular's onChange function.
+ */
+type ChangeFn<T> = (value: T) => void;
+/**
+ * A utility type for Angular's onTouched function.
+ */
+type TouchedFn = () => void;
+
+declare function booleanAttributeBinding(element: HTMLElement, attribute: string, value: Signal<boolean> | undefined): void;
+
+/**
+ * Disposable functions are a way to manage timers, intervals, and event listeners
+ * that should be cleared when a component is destroyed.
+ *
+ * This is heavily inspired by Headless UI disposables:
+ * https://github.com/tailwindlabs/headlessui/blob/main/packages/%40headlessui-react/src/utils/disposables.ts
+ */
+declare function injectDisposables(): {
+    /**
+     * Set a timeout that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @param delay The delay before the callback is executed
+     * @returns A function to clear the timeout
+     */
+    setTimeout: (callback: () => void, delay: number) => () => void;
+    /**
+     * Set an interval that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @param delay The delay before the callback is executed
+     * @param target
+     * @param type
+     * @param listener
+     * @param options
+     * @returns A function to clear the interval
+     */
+    addEventListener: <K extends keyof HTMLElementEventMap>(target: EventTarget, type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions) => () => void;
+    /**
+     * Set an interval that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @param delay The delay before the callback is executed
+     * @returns A function to clear the interval
+     */
+    setInterval: (callback: () => void, delay: number) => () => void;
+    /**
+     * Set a requestAnimationFrame that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @returns A function to clear the requestAnimationFrame
+     */
+    requestAnimationFrame: (callback: FrameRequestCallback) => () => void;
+};
+
+/**
+ * Generate a unique id for an element
+ * @param prefix - The prefix to use for the id
+ * @returns The generated id
+ */
+declare function uniqueId(prefix: string): string;
+
+/**
+ * Type validation utilities
+ */
+/**
+ * Checks if a value is a string
+ * @param value - The value to check
+ * @returns true if the value is a string, false otherwise
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * Checks if a value is a number
+ * @param value - The value to check
+ * @returns true if the value is a number, false otherwise
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a value is a boolean
+ * @param value - The value to check
+ * @returns true if the value is a boolean, false otherwise
+ */
+declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if a value is a function
+ * @param value - The value to check
+ * @returns true if the value is a function, false otherwise
+ */
+declare function isFunction(value: unknown): value is CallableFunction;
+/**
+ * Checks if a value is a plain object (but not null or array)
+ * @param value - The value to check
+ * @returns true if the value is a plain object, false otherwise
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a value is undefined
+ * @param value - The value to check
+ * @returns true if the value is undefined, false otherwise
+ */
+declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Checks if a value is null or undefined
+ * @param value - The value to check
+ * @returns true if the value is null or undefined, false otherwise
+ */
+declare function isNil(value: unknown): value is null | undefined;
+/**
+ * Checks if a value is not null and not undefined
+ * @param value - The value to check
+ * @returns true if the value is not null and not undefined, false otherwise
+ */
+declare function notNil<T>(value: T | null | undefined): value is T;
+
+/**
+ * The built-in `takeUntilDestroyed` operator does not handle the case when the component is destroyed before the source observable emits.
+ * This operator ensures that the source observable completes gracefully without throwing an error.
+ * https://github.com/angular/angular/issues/54527#issuecomment-2098254508
+ *
+ * @internal
+ */
+declare function safeTakeUntilDestroyed<T>(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T>;
+
+/**
+ * Listen for changes to a signal and call a function when the signal changes.
+ * @param source
+ * @param fn
+ * @param options
+ * @param options.injector
+ * @internal
+ */
+declare function onChange<T>(source: Signal<T | null | undefined>, fn: (value: T | null | undefined, previousValue: T | null | undefined) => void, options?: {
+    injector: Injector;
+}): void;
+/**
+ * Listen for changes to a boolean signal and call one of two functions when the signal changes.
+ * @param source
+ * @param onTrue
+ * @param onFalse
+ * @param options
+ */
+declare function onBooleanChange(source: Signal<boolean>, onTrue?: () => void, onFalse?: () => void, options?: {
+    injector: Injector;
+}): void;
+
+export { booleanAttributeBinding, controlStatus, injectDisposables, isBoolean, isFunction, isNil, isNumber, isObject, isString, isUndefined, notNil, onBooleanChange, onChange, provideValueAccessor, safeTakeUntilDestroyed, uniqueId };
+export type { ChangeFn, NgpControlStatus, TouchedFn };

package/a11y/active-descendant/active-descendant.d.ts

@@ -1,42 +0,0 @@
-import { ElementRef, Signal } from '@angular/core';
-interface ActiveDescendantManagerOptions<T extends NgpActivatable> {
-    /**
-     * The disabled state of the active descendant group.
-     * @default false
-     */
-    disabled?: Signal<boolean>;
-    /**
-     * The items in the active descendant group.
-     */
-    items: Signal<T[]>;
-    /**
-     * Whether active descendant should wrap around.
-     * @default false
-     */
-    wrap?: Signal<boolean>;
-}
-export interface NgpActivatable {
-    /**
-     * The id of the item.
-     */
-    id: Signal<string>;
-    /**
-     * Whether the item is disabled.
-     */
-    disabled?: Signal<boolean>;
-    /**
-     * The element that represents the item.
-     */
-    elementRef: ElementRef<HTMLElement>;
-}
-export declare function activeDescendantManager<T extends NgpActivatable>(options: ActiveDescendantManagerOptions<T>): {
-    activeDescendant: Signal<string | undefined>;
-    activeItem: Signal<T | undefined>;
-    activate: (item: T | undefined) => void;
-    first: () => void;
-    last: () => void;
-    next: () => void;
-    previous: () => void;
-    reset: () => void;
-};
-export {};

package/a11y/visually-hidden/visually-hidden-state.d.ts

@@ -1,17 +0,0 @@
-import type { NgpVisuallyHidden } from './visually-hidden';
-/**
- * The state token  for the VisuallyHidden primitive.
- */
-export declare const NgpVisuallyHiddenStateToken: import("@angular/core").InjectionToken<NgpVisuallyHidden>;
-/**
- * Provides the VisuallyHidden state.
- */
-export declare const provideVisuallyHiddenState: (options?: import("ng-primitives/state").CreateStateProviderOptions) => import("@angular/core").FactoryProvider;
-/**
- * Injects the VisuallyHidden state.
- */
-export declare const injectVisuallyHiddenState: <U = NgpVisuallyHidden>(injectOptions?: import("@angular/core").InjectOptions) => import("@angular/core").Signal<import("ng-primitives/state").State<U>>;
-/**
- * The VisuallyHidden state registration function.
- */
-export declare const visuallyHiddenState: <U>(state: U) => import("ng-primitives/state").CreatedState<U>;