@ngneers/controls 0.0.1-pre1

package/popover/index.d.ts

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { PositioningSizeConstraints } from '@ngneers/controls/api';
+
+type PopoverOptions = {
+    /**
+     * Constraints for the size of the popover.
+     */
+    sizeConstraints?: PositioningSizeConstraints;
+    /**
+     * If true, the content of the popover will be cached and not recreated on each open.
+     * This is useful for performance when the content is expensive to create.
+     */
+    cache?: boolean;
+};
+declare class Popover {
+    readonly anchor: _angular_core.InputSignal<HTMLElement>;
+    readonly options: _angular_core.InputSignal<PopoverOptions | undefined>;
+    protected readonly lazyContent: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    protected readonly appliedOptions: _angular_core.Signal<{
+        sizeConstraints?: PositioningSizeConstraints;
+        cache: boolean;
+    }>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly _isOpen;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    private readonly _injector;
+    private readonly _popoverRef;
+    private readonly _popover;
+    private readonly _autoPos;
+    open(): void;
+    toggle(): void;
+    close(): void;
+    protected onToggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Popover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Popover, "ngn-popover", never, { "anchor": { "alias": "anchor"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, ["lazyContent"], ["*"], true, never>;
+}
+
+export { Popover };
+export type { PopoverOptions };

package/scroller/index.d.ts

@@ -0,0 +1,95 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+declare class Scroller<T> {
+    /**
+     * The items to be displayed in the scroller.
+     * This is a required input and should be an array of items of type T.
+     */
+    readonly items: _angular_core.InputSignal<readonly T[]>;
+    /**
+     * Whether the scroller should use virtual scrolling.
+     * When set to true, the scroller will only render the items that are currently visible
+     * on the screen, improving performance for large lists.
+     *
+     * When virtual scrolling is enabled, {@link itemHeight} must be set to a non-zero value.
+     * @defaultValue `false`
+     */
+    readonly virtual: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * When {@link virtual} scrolling is enabled, this input is required to define the height of each item in pixels.
+     */
+    readonly itemHeight: _angular_core.InputSignal<number>;
+    /**
+     * When {@link virtual} scrolling is enabled, this input defines the number of items to be rendered above and below the visible area.
+     * This can help to reduce flickering when scrolling.
+     * @defaultValue `2`
+     */
+    readonly padding: _angular_core.InputSignal<number>;
+    /**
+     * Determines whether the scroller should have a tab index and be focusable.
+     * @defaultValue `false`
+     */
+    readonly focusable: _angular_core.InputSignal<boolean>;
+    /**
+     * Determines whether an item is sticky or not.
+     * If set, the scroller will stick the items with a truthy value for the specified field to the top of the scroller.
+     */
+    readonly fieldSticky: _angular_core.InputSignal<keyof T | null>;
+    private readonly _itemList;
+    /**
+     * The template to be used for rendering each item in the scroller.
+     * Can also be set using the `item` content child.
+     */
+    readonly templateItem: _angular_core.InputSignal<TemplateRef<{
+        $implicit: T;
+        index: number;
+    }> | null>;
+    private readonly _userItemTemplate;
+    protected readonly itemTemplate: _angular_core.Signal<TemplateRef<{
+        $implicit: T;
+        index: number;
+    }> | null>;
+    private readonly _el;
+    private readonly _scrollElement;
+    private readonly _elementSize;
+    private readonly _visibleItemCount;
+    private readonly _scrollTop;
+    private readonly _itemStartIndex;
+    private readonly _itemEndIndex;
+    protected readonly visibleItems: _angular_core.Signal<{
+        item: T;
+        index: number;
+    }[]>;
+    /**
+     * Returns the last sticky item that is not rendered regularly in the list.
+     * Required because sticky items might need to be rendered longer than they would.
+     * Only applicable when virtual scrolling is enabled.
+     */
+    protected readonly latestStickyItem: _angular_core.Signal<{
+        item: T;
+        index: number;
+    } | null>;
+    protected readonly itemsTop: _angular_core.Signal<number>;
+    protected readonly dummyHeight: _angular_core.Signal<number>;
+    constructor();
+    /**
+     * Scrolls the item with the given index into view.
+     * @param index The index of the item to scroll to.
+     */
+    scrollToIndex(index: number): void;
+    /**
+     * Template types for the scroller.
+     * Can be used with the {@link @ngneers/controls/api#NgnTemplate | NgnTemplate} directive for type safe ng-templates.
+     */
+    readonly templateTypes: {
+        item: {
+            $implicit: T;
+            index: number;
+        };
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Scroller<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Scroller<any>, "ngn-scroller", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "focusable": { "alias": "focusable"; "required": false; "isSignal": true; }; "fieldSticky": { "alias": "fieldSticky"; "required": false; "isSignal": true; }; "templateItem": { "alias": "templateItem"; "required": false; "isSignal": true; }; }, {}, ["_userItemTemplate"], never, true, never>;
+}
+
+export { Scroller };

package/select/index.d.ts

@@ -0,0 +1,86 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { ValueControlBase, NgnItem, FilterConfig, FilterConfigInternal, FilterFn, NgnItemFields } from '@ngneers/controls/api';
+import { PopoverOptions } from '@ngneers/controls/popover';
+
+declare abstract class SelectTemplates<T, K extends keyof T> extends ValueControlBase<T[K]> {
+    private readonly _defaultItemTemplate;
+    private readonly _userItemTemplate;
+    readonly templateItem: _angular_core.InputSignal<TemplateRef<{
+        $implicit: NgnItem<T, K> | undefined;
+    }> | null>;
+    protected readonly itemTemplate: _angular_core.Signal<TemplateRef<{
+        $implicit: NgnItem<T, K> | undefined;
+    }>>;
+    private readonly _defaultSelectedItemTemplate;
+    private readonly _userSelectedItemTemplate;
+    readonly templateSelectedItem: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    protected readonly selectedItemTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    private readonly _defaultGroupTemplate;
+    private readonly _userGroupTemplate;
+    readonly templateGroup: _angular_core.InputSignal<TemplateRef<{
+        $implicit: NgnItem<T, K> | undefined;
+    }> | null>;
+    protected readonly groupTemplate: _angular_core.Signal<TemplateRef<{
+        $implicit: NgnItem<T, K> | undefined;
+    }>>;
+    /**
+     * Types for the dialog templates.
+     */
+    readonly templateTypes: {
+        item: {
+            $implicit: NgnItem<T, K> | undefined;
+        };
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectTemplates<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectTemplates<any, any>, "ng-component", never, { "templateItem": { "alias": "templateItem"; "required": false; "isSignal": true; }; "templateSelectedItem": { "alias": "templateSelectedItem"; "required": false; "isSignal": true; }; "templateGroup": { "alias": "templateGroup"; "required": false; "isSignal": true; }; }, {}, ["_userItemTemplate", "_userSelectedItemTemplate", "_userGroupTemplate"], never, true, never>;
+}
+
+type _SelectFilterOptions = {
+    clearFilterOnClose?: boolean;
+};
+type SelectFilterOptions<T extends object> = _SelectFilterOptions & FilterConfig<T>;
+type SelectFilterOptionsInternal<T extends object> = _SelectFilterOptions & FilterConfigInternal<T>;
+type SelectFilterFn<T extends object> = FilterFn<NgnItem<T>>;
+
+declare class Select<T extends object, K extends keyof T> extends SelectTemplates<T, K> {
+    private readonly _popover;
+    readonly popoverOptions: _angular_core.InputSignal<PopoverOptions>;
+    protected readonly appliedPopoverOptions: _angular_core.Signal<{
+        sizeConstraints: {
+            width: number | string;
+            maxWidth: number | string;
+            height?: string;
+            maxHeight?: string;
+        };
+        cache?: boolean;
+    }>;
+    readonly options: _angular_core.InputSignal<readonly NgnItem<T, K>[] | readonly T[]>;
+    readonly fields: _angular_core.InputSignal<NgnItemFields<T, K> | undefined>;
+    readonly filter: _angular_core.InputSignal<boolean | SelectFilterOptions<NgnItem<T, K>> | undefined>;
+    readonly filterText: _angular_core.InputSignal<string | undefined>;
+    readonly filterIcon: _angular_core.InputSignal<string | undefined>;
+    readonly virtual: _angular_core.InputSignal<boolean>;
+    readonly itemHeight: _angular_core.InputSignal<number | undefined>;
+    private readonly _listbox;
+    protected readonly filterTextInternal: _angular_core.WritableSignal<string | undefined>;
+    protected readonly currentHighlightedValue: _angular_core.WritableSignal<T[K] | null>;
+    private readonly _options;
+    private readonly _flatOptions;
+    private readonly _appliedFilterOptions;
+    protected readonly filteredOptions: {
+        (): readonly NgnItem[];
+        isRunning: Signal<boolean>;
+    };
+    protected readonly filterIsExecuting: Signal<boolean>;
+    protected readonly selectedItem: _angular_core.Signal<NgnItem<any, any> | undefined>;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onPopoverClosed(): void;
+    onSelect(value: T[K]): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Select<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Select<any, any>, "ngn-select", never, { "popoverOptions": { "alias": "popoverOptions"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterText": { "alias": "filterText"; "required": false; "isSignal": true; }; "filterIcon": { "alias": "filterIcon"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Select };
+export type { SelectFilterFn, SelectFilterOptions, SelectFilterOptionsInternal };

package/text-field/index.d.ts

@@ -0,0 +1,10 @@
+import { ValueControlBase } from '@ngneers/controls/api';
+import * as i0 from '@angular/core';
+
+declare class TextField extends ValueControlBase<string> {
+    onInput(value: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextField, "ngn-text-field", never, {}, {}, never, never, true, never>;
+}
+
+export { TextField };

package/utils/index.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+
+declare function throwExp(message: string): never;
+
+declare function fuzzyMatch(input: string, search: string): boolean;
+
+declare function generateElementId(): string;
+
+declare const globalPropertyName = "__ngn-controls-global__";
+interface NgnGlobalType {
+    nextElementId: number;
+}
+declare global {
+    interface Window {
+        [globalPropertyName]: NgnGlobalType;
+    }
+}
+declare class NgnGlobal implements NgnGlobalType {
+    private readonly _window;
+    constructor();
+    get nextElementId(): number;
+    set nextElementId(value: number);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgnGlobal, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgnGlobal>;
+}
+
+declare function computedWithPrevious<T>(computeFn: (prev?: T) => T, previous?: T): () => T;
+declare function asyncComputed<T>(computeFn: () => Promise<T>, initial: T): {
+    (): T;
+    isRunning: Signal<boolean>;
+};
+
+declare function notNullish<T>(value: T | null | undefined): value is T;
+
+export { NgnGlobal, asyncComputed, computedWithPrevious, fuzzyMatch, generateElementId, notNullish, throwExp };