@qualcomm-ui/angular-core 1.0.1 → 1.0.3

package/select/index.d.ts

@@ -1,18 +1,381 @@
-export * from "./core-select-clear-trigger.directive";
-export * from "./core-select-content.directive";
-export * from "./core-select-control.directive";
-export * from "./core-select-error-indicator.directive";
-export * from "./core-select-error-text.directive";
-export * from "./core-select-hidden-select.directive";
-export * from "./core-select-hint.directive";
-export * from "./core-select-indicator.directive";
-export * from "./core-select-item-indicator.directive";
-export * from "./core-select-item-text.directive";
-export * from "./core-select-item.directive";
-export * from "./core-select-label.directive";
-export * from "./core-select-positioner.directive";
-export * from "./core-select-root.directive";
-export * from "./core-select-value-text.directive";
-export * from "./select-context.service";
-export * from "./select-item-context.service";
-//# sourceMappingURL=index.d.ts.map
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+import * as _qualcomm_ui_core_select from '@qualcomm-ui/core/select';
+import { ItemState, ItemProps, SelectValueChangeDetails, SelectApi, SelectApiProps, ScrollToIndexDetails, HighlightChangeDetails } from '@qualcomm-ui/core/select';
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+import { AbstractListCollectionFormControlDirective } from '@qualcomm-ui/angular-core/input';
+import { PositioningOptions } from '@qualcomm-ui/dom/floating-ui';
+import { FocusOutsideEvent, InteractOutsideEvent, PointerDownOutsideEvent } from '@qualcomm-ui/dom/interact-outside';
+import * as _qualcomm_ui_utils_collection from '@qualcomm-ui/utils/collection';
+import { CollectionItem } from '@qualcomm-ui/utils/collection';
+import { Direction } from '@qualcomm-ui/utils/direction';
+
+declare class CoreSelectClearTriggerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly hostId: _angular_core.Signal<string>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectClearTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectClearTriggerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectContentDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly hostId: _angular_core.Signal<string>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectContentDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectControlDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly hostId: _angular_core.Signal<string>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectControlDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectErrorIndicatorDirective implements OnInit {
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectErrorIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectErrorIndicatorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreSelectErrorTextDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectErrorTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectErrorTextDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectHiddenSelectDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    private readonly hostId;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    private readonly onDestroy;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectHiddenSelectDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectHiddenSelectDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectHintDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectHintDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectHintDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectIndicatorDirective implements OnInit {
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectIndicatorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreSelectItemIndicatorDirective implements OnInit {
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly selectItemContext: () => _qualcomm_ui_core_select.ItemState;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectItemIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectItemIndicatorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreSelectItemTextDirective implements OnInit {
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly selectItemContext: () => _qualcomm_ui_core_select.ItemState;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectItemTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectItemTextDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class SelectItemContextService extends BaseApiContextService<ItemState> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectItemContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SelectItemContextService>;
+}
+declare const SELECT_ITEM_CONTEXT: _angular_core.InjectionToken<() => ItemState>;
+declare const useSelectItemContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => ItemState) | null : () => ItemState;
+declare const provideSelectItemContext: () => _angular_core.Provider[];
+
+declare class CoreSelectItemDirective implements SignalifyInput<ItemProps>, OnInit {
+    /**
+     * The item to render, from the collection
+     */
+    readonly item: _angular_core.InputSignal<any>;
+    /**
+     * Whether hovering outside should clear the highlighted state
+     */
+    readonly persistFocus: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly selectItemService: SelectItemContextService;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectItemDirective, never, never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; "persistFocus": { "alias": "persistFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectLabelDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly hostId: _angular_core.Signal<string>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectLabelDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreSelectPositionerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    private readonly hostId;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectPositionerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectPositionerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SelectValueChangeEvent<T> extends SelectValueChangeDetails<T> {
+    value: string[];
+}
+declare class SelectContextService extends BaseApiContextService<SelectApi> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SelectContextService>;
+}
+declare const SELECT_CONTEXT: _angular_core.InjectionToken<() => SelectApi<any>>;
+declare const useSelectContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => SelectApi<any>) | null : () => SelectApi<any>;
+declare const provideSelectContext: () => _angular_core.Provider[];
+
+declare class CoreSelectRootDirective<T extends CollectionItem = CollectionItem> extends AbstractListCollectionFormControlDirective<T> implements Omit<SignalifyInput<SelectApiProps>, "defaultValue" | "form" | "ids" | "value">, OnInit {
+    /**
+     * Whether the select should close after an item is selected
+     *
+     * @default true
+     */
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The initial value of the highlighted item when opened.
+     * Use when you don't need to control the highlighted value of the select.
+     */
+    readonly defaultHighlightedValue: _angular_core.InputSignal<string | null | undefined>;
+    /**
+     * Whether the select's open state is controlled by the user
+     */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether the value can be cleared by clicking the selected item.
+     *
+     * This is only applicable for single selection.
+     */
+    readonly deselectable: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The document's text/writing direction.
+     *
+     * @default "ltr"
+     */
+    readonly dir: _angular_core.InputSignal<Direction | undefined>;
+    /**
+     * A root node to correctly resolve the Document in custom environments. i.e.,
+     * Iframes, Electron.
+     */
+    readonly getRootNode: _angular_core.InputSignal<(() => ShadowRoot | Document | Node) | undefined>;
+    /**
+     * The controlled key of the highlighted item
+     */
+    readonly highlightedValue: _angular_core.InputSignal<string | null | undefined>;
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.)
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether to loop the keyboard navigation through the options
+     *
+     * @default false
+     */
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether to allow multiple selection
+     *
+     * @default false
+     */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether the select menu is open
+     */
+    readonly open: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Placeholder text to display when no value is selected.
+     *
+     * @default "Select option"
+     */
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The positioning options of the menu.
+     *
+     * @inheritDoc
+     */
+    readonly positioning: _angular_core.InputSignal<PositioningOptions | undefined>;
+    /**
+     * Function to scroll to a specific index
+     */
+    readonly scrollToIndexFn: _angular_core.InputSignal<((details: ScrollToIndexDetails) => void) | undefined>;
+    /**
+     * Function called when the focus is moved outside the component
+     */
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusOutsideEvent>;
+    /**
+     * The callback fired when the highlighted item changes.
+     */
+    readonly highlightChanged: _angular_core.OutputEmitterRef<{
+        value: string | null;
+    } & HighlightChangeDetails<T>>;
+    /**
+     * Function called when an interaction happens outside the component
+     */
+    readonly interactOutside: _angular_core.OutputEmitterRef<InteractOutsideEvent>;
+    /**
+     * Function invoked when the popup opens or closes
+     */
+    readonly openChanged: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Function called when the pointer is pressed down outside the component
+     */
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerDownOutsideEvent>;
+    /**
+     * Function called when an item is selected
+     */
+    readonly selected: _angular_core.OutputEmitterRef<{
+        value: string | undefined;
+    }>;
+    /**
+     * The callback fired when the selected item changes.
+     */
+    readonly valueChanged: _angular_core.OutputEmitterRef<SelectValueChangeEvent<T>>;
+    protected readonly document: Document;
+    protected readonly isMounted: () => boolean;
+    protected readonly hostId: _angular_core.Signal<string>;
+    protected readonly selectContext: SelectContextService;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectRootDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectRootDirective<any>, never, never, { "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "defaultHighlightedValue": { "alias": "defaultHighlightedValue"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "deselectable": { "alias": "deselectable"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "getRootNode": { "alias": "getRootNode"; "required": false; "isSignal": true; }; "highlightedValue": { "alias": "highlightedValue"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "positioning": { "alias": "positioning"; "required": false; "isSignal": true; }; "scrollToIndexFn": { "alias": "scrollToIndexFn"; "required": false; "isSignal": true; }; }, { "focusOutside": "focusOutside"; "highlightChanged": "highlightChanged"; "interactOutside": "interactOutside"; "openChanged": "openChanged"; "pointerDownOutside": "pointerDownOutside"; "selected": "selected"; "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class CoreSelectValueTextDirective implements OnInit {
+    readonly collection: _angular_core.Signal<_qualcomm_ui_utils_collection.ListCollection<any>>;
+    readonly placeholder: _angular_core.Signal<string>;
+    readonly valueAsString: _angular_core.Signal<string>;
+    readonly value: _angular_core.Signal<string[]>;
+    protected readonly selectContext: () => _qualcomm_ui_core_select.SelectApi<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectValueTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectValueTextDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+export { CoreSelectClearTriggerDirective, CoreSelectContentDirective, CoreSelectControlDirective, CoreSelectErrorIndicatorDirective, CoreSelectErrorTextDirective, CoreSelectHiddenSelectDirective, CoreSelectHintDirective, CoreSelectIndicatorDirective, CoreSelectItemDirective, CoreSelectItemIndicatorDirective, CoreSelectItemTextDirective, CoreSelectLabelDirective, CoreSelectPositionerDirective, CoreSelectRootDirective, CoreSelectValueTextDirective, SELECT_CONTEXT, SELECT_ITEM_CONTEXT, SelectContextService, SelectItemContextService, provideSelectContext, provideSelectItemContext, useSelectContext, useSelectItemContext };
+export type { SelectValueChangeEvent };
+//# sourceMappingURL=index.d.ts.map

package/select/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/select/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA;AACrD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,yCAAyC,CAAA;AACvD,cAAc,oCAAoC,CAAA;AAClD,cAAc,uCAAuC,CAAA;AACrD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,mCAAmC,CAAA;AACjD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,oCAAoC,CAAA;AAClD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,oCAAoC,CAAA;AAClD,cAAc,0BAA0B,CAAA;AACxC,cAAc,+BAA+B,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/select/core-select-clear-trigger.directive.ts","../../src/select/core-select-content.directive.ts","../../src/select/core-select-control.directive.ts","../../src/select/core-select-error-indicator.directive.ts","../../src/select/core-select-error-text.directive.ts","../../src/select/core-select-hidden-select.directive.ts","../../src/select/core-select-hint.directive.ts","../../src/select/core-select-indicator.directive.ts","../../src/select/core-select-item-indicator.directive.ts","../../src/select/core-select-item-text.directive.ts","../../src/select/select-item-context.service.ts","../../src/select/core-select-item.directive.ts","../../src/select/core-select-label.directive.ts","../../src/select/core-select-positioner.directive.ts","../../src/select/select-context.service.ts","../../src/select/core-select-root.directive.ts","../../src/select/core-select-value-text.directive.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;;;;;;AAUA;AAEE;;;AAGG;;AAGH;AAEA;AAEA;;;;AAOC;;;;AAKF;;ACxBD;AAEE;;;AAGG;;AAGH;AAEA;AAEA;;;;AAOC;;;;AAKF;;ACxBD;AAEE;;;AAGG;;AAGH;;;;AAOC;AAED;AAEA;;;;AAKD;;ACzBD;AAEE;;;;AAIE;;;;AAKH;;ACVD;AAEE;;;AAGG;;AAGH;;;;AAOE;AAEF;AAEA;;;;AAKD;;ACxBD;AAEE;;;AAGG;;AAGH;AAEA;AAEA;;;;AAOC;;;;AAKF;;ACxBD;AAEE;;;AAGG;;AAGH;;;;AAOE;AAEF;AAEA;;;;AAKD;;ACzBD;AAEE;;;;AAIE;;;;AAKH;;ACVD;AAEE;AACA;;;;AAIC;;;;AAKF;;ACZD;AAEE;AACA;;;;AAIC;;;;AAKF;;ACVD;;;AACiF;AAEjF;AACqB;AACC;;ACKtB;AAIE;;AAEG;;AAGH;;AAEG;;AAKH;AAEA;;;;AAIC;;;;AAcF;;AChDD;AAEE;;;AAGG;;AAGH;AAEA;AAEA;;;;AAOC;;;;AAKF;;ACxBD;AAEE;;;AAGG;;AAGH;AAEA;AAEA;;;;AAOC;;;;AAKF;;ACnBK;;AAEL;AAED;;;AAC6E;AAE7E;AACgB;AACE;;ACqBlB;AAUE;;;;AAIG;;AAKH;;;AAGG;;AAGH;;AAEG;;AAKH;;;;AAIG;;AAKH;;;;AAIG;;AAGH;;;AAGG;;AAGH;;AAEG;;AAGH;;;AAGG;;AAGH;;;;AAIG;;AAKH;;;;AAIG;;AAKH;;AAEG;;AAKH;;;;AAIG;;AAGH;;;;AAIG;;AAGH;;AAEG;AACH;AAIA;;AAEG;;AAGH;;AAEG;AACH;AACU;AACP;AAEH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;AACH;AAAmC;AAAsB;AAEzD;;AAEG;;AAGH;AACA;AACA;AACA;;;;AAOC;;;;AAuGF;;ACzSD;;;;;AAOE;;;;AAIC;;;;AAKF;;;"}

package/signals/index.d.ts

@@ -1,6 +1,85 @@
-export * from "./access-signal";
-export * from "./host-binding";
-export type * from "./signalify-input";
-export * from "./signalify-object";
-export type * from "./signals.types";
-//# sourceMappingURL=index.d.ts.map
+import { Signal, Injector, WritableSignal, HostBinding } from '@angular/core';
+
+type MaybeSignal<T> = T | Signal<T>;
+
+/**
+ * Accesses the value of a signal if the provided input is a signal; otherwise,
+ * returns the input directly.
+ *
+ * @param {T | Signal<T>} maybeSignal - The input which can either be a signal or a direct value of type T.
+ * @return {T} The resolved value of the signal if the input is a signal, or the input value itself if it is not a signal.
+ */
+declare function accessSignal<T>(maybeSignal: MaybeSignal<T>): T;
+
+/**
+ * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
+ * After assertion, `assertInjector` runs the `runner` function with the guaranteed
+ * `Injector` whether it is the default `Injector` within the current **Injection
+ * Context** or the custom `Injector` that was passed in.
+ *
+ * @template {() => any} Runner - Runner is a function that can return anything
+ * @param {Function} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Injector | undefined | null} injector - the optional "custom" Injector
+ * @param {Runner} runner - the runner fn
+ * @returns {ReturnType<Runner>} result - returns the result of the Runner
+ *
+ * @example
+ * ```ts
+ * function injectValue(injector?: Injector) {
+ *  return assertInjector(injectValue, injector, () => 'value');
+ * }
+ *
+ * injectValue(); // string
+ * ```
+ */
+declare function assertInjector<Runner extends () => any>(fn: Function, injector: Injector | undefined | null, runner: Runner): ReturnType<Runner>;
+/**
+ * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
+ * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is
+ * the default `Injector` within the current **Injection Context** or the custom
+ * `Injector` that was passed in.
+ *
+ * @param {Function} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Injector | undefined | null} injector - the optional "custom" Injector
+ * @returns Injector
+ */
+declare function assertInjector(fn: Function, injector: Injector | undefined | null): Injector;
+/**
+ * `hostBinding` takes a `hostPropertyName` to attach a data property, a class, a
+ * style or an attribute (as `@HostBinding` would) to the host. The update is
+ * applied based on the update of the provided signal.
+ *
+ * @param hostPropertyName - the same property that is bound to a data property, a class, a style or an attribute as `@HostBinding`.
+ * @param signal - the signal on which to react to changes to update the host, and the one that will be returned as it is
+ * @returns {Signal | WritableSignal}
+ *
+ * @example
+ * ```ts
+ * export class MyComponent {
+ *  readonly background = hostBinding('style.background', signal('blue'));
+ *
+ *  constructor() {
+ *    setTimeout(() => this.background.set('red'), 3000);
+ *  }
+ * }
+ * ```
+ *
+ * TODO: verify with SSR
+ */
+declare function hostBinding<T, S extends Signal<T> | WritableSignal<T>>(hostPropertyName: Required<HostBinding>["hostPropertyName"], signal: S, injector?: Injector): S;
+
+type SignalifyInput<T> = {
+    [Key in keyof T as Key extends `on${string}` ? never : Key]-?: Signal<T[Key]>;
+};
+type MaybeSignalInput<T> = {
+    [Key in keyof T as Key extends `on${string}` ? never : Key]-?: MaybeSignal<T[Key]>;
+};
+
+/**
+ * Converts an object's function properties to computed signals.
+ */
+declare function signalifyObject<T extends Record<string, any>>(someObject: T): T;
+
+export { accessSignal, assertInjector, hostBinding, signalifyObject };
+export type { MaybeSignal, MaybeSignalInput, SignalifyInput };
+//# sourceMappingURL=index.d.ts.map

package/signals/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/signals/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,mBAAmB,mBAAmB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,mBAAmB,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/signals/signals.types.ts","../../src/signals/access-signal.ts","../../src/signals/host-binding.ts","../../src/signals/signalify-input.ts","../../src/signals/signalify-object.ts"],"sourcesContent":[null,null,null,null,null],"names":[],"mappings":";;AAKM;;ACEN;;;;;;AAMG;AACH;;ACGA;;;;;;;;;;;;;;;;;;;;AAoBG;AACH;AAMA;;;;;;;;;AASG;AACH;AAoBA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH;;ACzFM;;;AAIA;;;;ACNN;;AAEG;AACH;;;"}

package/state/index.d.ts

@@ -1,4 +1,105 @@
-export * from "./controlled-state.service";
-export * from "./controlled-state-legacy";
-export * from "./use-controlled-state";
-//# sourceMappingURL=index.d.ts.map
+import * as _angular_core from '@angular/core';
+import { SimpleChange, OutputEmitterRef, Signal } from '@angular/core';
+import { Subject } from 'rxjs';
+
+declare class ControlledStateService<T, OnChangeArg = Event> {
+    readonly valueChanged: Subject<T | undefined>;
+    protected onChange?: (value: T, event?: OnChangeArg) => void;
+    protected value: T | undefined;
+    protected initialized: boolean;
+    protected name: string;
+    protected state: string;
+    protected controlledValue: T | undefined;
+    get controlled(): boolean;
+    protected _controlled: boolean;
+    init(
+    /**
+     * The controlled value.
+     */
+    controlledValue: T | undefined, 
+    /**
+     * The default value.
+     */
+    defaultValue: T | undefined, 
+    /**
+     * onChange function fired when the state is modified internally. If the
+     * controlled state is modified from outside of this service, this function will
+     * not be called.
+     */
+    onChange: (value: T, event?: OnChangeArg) => void, 
+    /**
+     * The name of this instance. Used in error logging.
+     */
+    name: string, 
+    /**
+     * The name of the tracked property. Used in error logging.
+     */
+    state: string): void;
+    set(value: T, event?: OnChangeArg): void;
+    get(): T | undefined;
+    private emitWarning;
+    handleOnChange(change?: SimpleChange): void;
+}
+
+declare class ControlledStateLegacy<T, OnChangeParams extends Record<string, any> | null = null> {
+    /**
+     * onChange function fired when the state is modified internally. If the
+     * controlled state is modified from outside of this service, this function will
+     * not be called.
+     */
+    private onChange;
+    /**
+     * The name of this instance. Used in error logging.
+     */
+    private name;
+    /**
+     * The name of the tracked property. Used in error logging.
+     */
+    private state;
+    get controlled(): _angular_core.Signal<boolean>;
+    protected readonly value: _angular_core.WritableSignal<T | undefined>;
+    protected readonly controlledValue: _angular_core.WritableSignal<T | undefined>;
+    private readonly _controlled;
+    constructor(
+    /**
+     * The controlled value.
+     */
+    controlledValue: T | undefined, 
+    /**
+     * The default value.
+     */
+    defaultValue: T | undefined, 
+    /**
+     * onChange function fired when the state is modified internally. If the
+     * controlled state is modified from outside of this service, this function will
+     * not be called.
+     */
+    onChange: OutputEmitterRef<any>, 
+    /**
+     * The name of this instance. Used in error logging.
+     */
+    name: string, 
+    /**
+     * The name of the tracked property. Used in error logging.
+     */
+    state: string);
+    set(value: T, options?: OnChangeParams): void;
+    readonly get: _angular_core.Signal<T | undefined>;
+    private emitWarning;
+    handleOnChange(change?: SimpleChange): void;
+}
+
+interface ControlledStateOptions<T> {
+    defaultValue?: Signal<T | undefined> | T | undefined;
+    onChange?: ((value: T, ...rest: any[]) => void) | undefined;
+    value?: Signal<T | undefined>;
+}
+interface ControlledState<T> {
+    setValue: (newValue: T, ...rest: any[]) => void;
+    value: Signal<T | undefined>;
+}
+declare function useControlledState<T>(options: ControlledStateOptions<T>): Signal<ControlledState<T>>;
+
+export { ControlledStateLegacy, ControlledStateService, useControlledState };
+export type { ControlledState };
+//# sourceMappingURL=index.d.ts.map

package/state/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/state/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,2BAA2B,CAAA;AACzC,cAAc,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/state/controlled-state.service.ts","../../src/state/controlled-state-legacy.ts","../../src/state/use-controlled-state.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;AAQA;;AAGE;AACA;;AAEA;AACA;AACA;AAEA;AAGA;;AAGE;;AAEG;;AAEH;;AAEG;;AAEH;;;;AAIG;;AAEH;;AAEG;AACH;AACA;;AAEG;AACH;;;AA0BF;AAgBA;AAeD;;ACzFD;AAoBI;;;;AAIG;AACH;AACA;;AAEG;AACH;AACA;;AAEG;AACH;AA7BF;AAGA;AACA;AACA;;AAGE;;AAEG;;AAEH;;AAEG;;AAEH;;;;AAIG;AACK;AACR;;AAEG;AACK;AACR;;AAEG;AACK;;;AAqBV;AAgBA;AAeD;;AC7FD;AACE;AACA;;AAED;AAEK;AACJ;AACA;AACD;AAED;;;"}