@basis-ng/primitives 0.0.1-alpha.0

package/core/components/search/search.component.d.ts

@@ -0,0 +1,121 @@
+import { Option } from '../../../public-api';
+import * as i0 from "@angular/core";
+export declare class Search {
+    /**
+     * The label associated with the search component.
+     */
+    readonly label: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * The maximum width of the search component.
+     */
+    readonly maxWidth: import("@angular/core").InputSignal<string>;
+    /**
+     * The placeholder of the text field.
+     */
+    readonly placeholder: import("@angular/core").InputSignal<string>;
+    /**
+     * Indicates whether the search component is searching.
+     */
+    readonly searching: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Indicates whether the search component is in an invalid state.
+     */
+    readonly invalid: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Indicates whether the search component is disabled.
+     */
+    readonly disabled: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * The value of the selected option.
+     */
+    readonly selectedValue: import("@angular/core").ModelSignal<string | null>;
+    /**
+     * The search value.
+     */
+    readonly searchValue: import("@angular/core").ModelSignal<string>;
+    /**
+     * Emits the value of the search component when the value changes.
+     */
+    searchChange: import("@angular/core").OutputEmitterRef<string>;
+    /**
+     * Emits when the search component is focused.
+     */
+    readonly focused: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Indicates whether the options dropdown is open.
+     */
+    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * The options available for selection.
+     */
+    readonly options: import("@angular/core").Signal<readonly Option[]>;
+    /**
+     * Indicates whether the search component has no options.
+     */
+    readonly noOptions: import("@angular/core").Signal<boolean>;
+    /**
+     * Reference to the select element within the component
+     * @private
+     */
+    private readonly select;
+    /**
+     * Reference to the renderer
+     * @private
+     */
+    private readonly renderer;
+    /**
+     * The icon name to display.
+     */
+    readonly selectIconName: import("@angular/core").Signal<"LoaderCircle" | "X" | "ChevronDown">;
+    /**
+     * The icon size to display.
+     */
+    readonly selectIconSize: import("@angular/core").Signal<20 | 17 | 18>;
+    /**
+     * The debounce time for the search input.
+     */
+    readonly debounceTime: import("@angular/core").InputSignal<number>;
+    /**
+     * Reference to the UtilsService
+     * @private
+     */
+    private readonly utilsService;
+    /**
+     * Initializes the search component.
+     */
+    constructor();
+    /**
+     * Renders the options within the select element.
+     * @private
+     */
+    private renderOptions;
+    /**
+     * Handles the change event of the input text.
+     */
+    onInputValueChange(event: any): void;
+    /**
+     * Resets the search component.
+     */
+    reset(): void;
+    /**
+     * Handles the selection change event from the native select element.
+     * @param event The selection change event.
+     */
+    onSelectValueChange(event: Event): void;
+    /**
+     * Handles click events outside the select component to close the options dropdown.
+     * @param event The mouse click event.
+     */
+    protected onOutsideClick(event: MouseEvent): void;
+    /**
+     * Handles keyboard events to open or close the options dropdown.
+     * @param event The keyboard event.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Handles the icon click event.
+     */
+    handleIconClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Search, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Search, "r-search", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searching": { "alias": "searching"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectedValue": { "alias": "selectedValue"; "required": false; "isSignal": true; }; "searchValue": { "alias": "searchValue"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; }, { "searching": "searchingChange"; "invalid": "invalidChange"; "disabled": "disabledChange"; "selectedValue": "selectedValueChange"; "searchValue": "searchValueChange"; "searchChange": "searchChange"; }, ["options"], ["*"], true, never>;
+}

package/core/components/select/select.component.d.ts

@@ -0,0 +1,48 @@
+import { AfterViewInit, ElementRef, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class Select implements AfterViewInit {
+    /**
+     * The value of the input.
+     */
+    readonly value: import("@angular/core").WritableSignal<string | null>;
+    /**
+     * Whether the input is invalid.
+     */
+    readonly invalid: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Whether the input is disabled.
+     */
+    readonly disabled: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * The maximum width of the input.
+     */
+    readonly maxWidth: import("@angular/core").InputSignal<string>;
+    /**
+     * Event emitted when the value changes.
+     */
+    valueChange: import("@angular/core").OutputEmitterRef<string | null>;
+    /**
+     * Reference to the input element.
+     */
+    readonly el: ElementRef<HTMLSelectElement>;
+    /**
+     * Indicates whether the options dropdown is open.
+     */
+    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Reference to the renderer
+     * @private
+     */
+    readonly renderer: Renderer2;
+    /**
+     * After the view has been initialized, set the value of the select.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * Handles the select change event.
+     * @param value - The value of the select.
+     */
+    change(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Select, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Select, "select[r-select]", never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, { "invalid": "invalidChange"; "disabled": "disabledChange"; "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}

package/core/components/side-sheet/side-sheet.component.d.ts

@@ -0,0 +1,46 @@
+import * as i0 from "@angular/core";
+/**
+ * A sliding sheet component that can be positioned on either side of the screen.
+ * The sheet slides in from the left or right edge and includes an overlay backdrop.
+ *
+ * @selector r-side-sheet
+ */
+export declare class SideSheet {
+    /**
+     * Indicates whether the side sheet is open.
+     */
+    readonly isOpen: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Specifies the side of the screen where the sheet is positioned.
+     * Can be either 'left' or 'right'.
+     */
+    readonly side: import("@angular/core").InputSignal<"left" | "right">;
+    /**
+     * Specifies the width of the side sheet.
+     */
+    readonly width: import("@angular/core").InputSignal<string>;
+    /**
+     * Computes whether the side sheet is positioned on the left side.
+     */
+    readonly isLeft: import("@angular/core").Signal<boolean>;
+    /**
+     * Computes whether the side sheet is positioned on the right side.
+     */
+    readonly isRight: import("@angular/core").Signal<boolean>;
+    /**
+     * Event emitted when the side sheet is closed.
+     */
+    closeSheet: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * Reference to the host element of the side sheet.
+     */
+    private readonly el;
+    /**
+     * Closes the side sheet when clicking outside of it.
+     *
+     * @param event - The click event.
+     */
+    closeOnOutsideClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideSheet, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SideSheet, "r-side-sheet", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closeSheet": "closeSheet"; }, never, ["*"], true, never>;
+}

package/core/components/spinner/spinner.component.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class Spinner {
+    readonly active: import("@angular/core").InputSignal<boolean>;
+    readonly color: import("@angular/core").InputSignal<string>;
+    readonly backgroundColor: import("@angular/core").InputSignal<string>;
+    readonly size: import("@angular/core").InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Spinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Spinner, "r-spinner", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/core/components/switch/switch.component.d.ts

@@ -0,0 +1,35 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class Switch implements AfterViewInit {
+    /**
+     * Value of the switch.
+     */
+    readonly value: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * The size of the switch.
+     */
+    readonly size: import("@angular/core").InputSignal<"default" | "large">;
+    /**
+     * Reference to the switch element.
+     */
+    el: ElementRef<any>;
+    /**
+     * Event emitted when the value changes.
+     */
+    valueChange: import("@angular/core").OutputEmitterRef<boolean>;
+    /**
+     * Initializes the switch value after the view is initialized.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * Toggles the value of the switch.
+     */
+    toggleValue(): void;
+    /**
+     * Sets the value of the switch.
+     * @param newValue - The new value to set.
+     */
+    setValue(newValue: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Switch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Switch, "input[r-switch]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/core/components/table/components/row/components/row-item/row-item.component.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class RowItem {
+    readonly widthPx: import("@angular/core").InputSignal<number | undefined>;
+    readonly alignedLeft: import("@angular/core").InputSignal<boolean>;
+    readonly isHeader: import("@angular/core").InputSignal<boolean>;
+    readonly style: import("@angular/core").Signal<{
+        width: string;
+        justifyContent: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RowItem, "r-row-item", never, { "widthPx": { "alias": "widthPx"; "required": false; "isSignal": true; }; "alignedLeft": { "alias": "alignedLeft"; "required": false; "isSignal": true; }; "isHeader": { "alias": "isHeader"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/core/components/table/components/row/row.component.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class Row {
+    readonly header: import("@angular/core").InputSignal<boolean>;
+    readonly subheader: import("@angular/core").InputSignal<boolean>;
+    readonly clickable: import("@angular/core").InputSignal<boolean>;
+    readonly highlighted: import("@angular/core").InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Row, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Row, "r-row", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "subheader": { "alias": "subheader"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "highlighted": { "alias": "highlighted"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/core/components/table/table.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class Table {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Table, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Table, "r-table", never, {}, {}, never, ["[r-row-header]", "[r-row-subheader]", "*"], true, never>;
+}

package/core/components/tabs/components/tab/tab.component.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class Tab {
+    el: ElementRef;
+    readonly value: import("@angular/core").InputSignal<string>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly selected: import("@angular/core").WritableSignal<boolean>;
+    readonly highlighted: import("@angular/core").WritableSignal<boolean>;
+    selectEmitter: import("@angular/core").OutputEmitterRef<Tab>;
+    constructor(el: ElementRef);
+    /**
+     * Emit the select event when the tab is selected.
+     */
+    onSelect(): void;
+    /**
+     * Highlight the tab on mouse enter if it is not disabled and not in keyboard-active mode.
+     */
+    onMouseEnter(): void;
+    /**
+     * Remove the highlight from the tab on mouse leave if it is not disabled and not in keyboard-active mode.
+     */
+    onMouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Tab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Tab, "r-tab", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selectEmitter": "selectEmitter"; }, never, ["*"], true, never>;
+}

package/core/components/tabs/tabs.component.d.ts

@@ -0,0 +1,60 @@
+import { Tab } from './components/tab/tab.component';
+import * as i0 from "@angular/core";
+export declare class Tabs {
+    readonly tabs: import("@angular/core").Signal<readonly Tab[]>;
+    readonly selectedIndex: import("@angular/core").WritableSignal<number>;
+    readonly selectedValue: import("@angular/core").ModelSignal<string | null>;
+    readonly highlightedIndex: import("@angular/core").WritableSignal<number>;
+    changesEmitter: import("@angular/core").OutputEmitterRef<string>;
+    lastSelectedValue: string | null;
+    constructor();
+    /**
+     * Handle the selection of a tab.
+     */
+    handleTabSelection(): void;
+    /**
+     * Select a tab.
+     * @param {Tab} tab - The tab to select.
+     * @param {number} index - The index of the tab.
+     */
+    selectTab(tab: Tab, index: number): void;
+    /**
+     * Highlight a tab.
+     * @param {number} index - The index of the tab to highlight.
+     */
+    highlightTab(index: number): void;
+    /**
+     * Handle the states of the tabs.
+     */
+    handleTabStates(): void;
+    /**
+     * Handle the external selected value.
+     */
+    handleExternalSelectedValue(): void;
+    /**
+     * Scroll to the selected tab.
+     */
+    handleScrollToSelectedTab(): void;
+    /**
+     * Handle keyboard events for navigation and selection.
+     * @param {KeyboardEvent} event - The keyboard event.
+     */
+    handleKeyboard(event: KeyboardEvent): void;
+    /**
+     * Focus on the next or previous tab.
+     * @param {'next' | 'previous'} direction - The direction to move the focus.
+     */
+    focusOption(direction: 'next' | 'previous'): void;
+    /**
+     * Select the currently focused tab.
+     */
+    selectFocusedTab(): void;
+    /**
+     * Scroll to a specific tab.
+     * @param {number} index - The index of the tab to scroll to.
+     * @param {string} behavior - The scroll behavior ('instant' or 'smooth').
+     */
+    scrollToTab(index: number, behavior: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Tabs, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Tabs, "r-tabs", never, { "selectedValue": { "alias": "selectedValue"; "required": false; "isSignal": true; }; }, { "selectedValue": "selectedValueChange"; "changesEmitter": "changesEmitter"; }, ["tabs"], ["*"], true, never>;
+}

package/core/components/textarea/textarea.component.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class Textarea {
+    /**
+     * The placeholder text for the textarea.
+     */
+    readonly placeholder: import("@angular/core").InputSignal<string>;
+    /**
+     * The value of the textarea.
+     */
+    readonly value: import("@angular/core").WritableSignal<string | null>;
+    /**
+     * The number of rows for the textarea.
+     */
+    readonly rows: import("@angular/core").InputSignal<number>;
+    /**
+     * The number of columns for the textarea.
+     */
+    readonly cols: import("@angular/core").InputSignal<number>;
+    /**
+     * Whether the textarea is invalid.
+     */
+    readonly invalid: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Whether the textarea is disabled.
+     */
+    readonly disabled: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Whether the textarea is focused.
+     * This will be used by the Label component.
+     */
+    readonly focused: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Event emitted when the value changes.
+     */
+    valueChange: import("@angular/core").OutputEmitterRef<string | null>;
+    /**
+     * Reference to the textarea element.
+     */
+    readonly el: ElementRef<HTMLTextAreaElement>;
+    /**
+     * Handles the input event.
+     * @param event The input event.
+     */
+    onInput(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Textarea, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Textarea, "textarea[r-textarea]", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "invalid": "invalidChange"; "disabled": "disabledChange"; "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/core/components/tooltip/tooltip.component.d.ts

@@ -0,0 +1,36 @@
+import { Position } from '../attached-box/types/position.type';
+import * as i0 from "@angular/core";
+/**
+ * TooltipComponent is a reusable UI component that displays a tooltip
+ * with customizable position, gap, variant, and size.
+ */
+export declare class TooltipComponent {
+    /**
+     * The position of the tooltip relative to its trigger element.
+     * Defaults to 'top-center'.
+     */
+    readonly position: import("@angular/core").InputSignal<Position>;
+    /**
+     * The gap (in pixels) between the tooltip and its trigger element.
+     * Defaults to 8.
+     */
+    readonly gap: import("@angular/core").InputSignal<number>;
+    /**
+     * The visual variant of the tooltip. Options include:
+     * - 'primary'
+     * - 'secondary'
+     * - 'ghost'
+     * - 'outlined'
+     * Defaults to 'primary'.
+     */
+    readonly variant: import("@angular/core").InputSignal<"primary" | "secondary" | "ghost" | "outlined">;
+    /**
+     * The size of the tooltip. Options include:
+     * - 'small'
+     * - 'default'
+     * Defaults to 'default'.
+     */
+    readonly size: import("@angular/core").InputSignal<"small" | "default">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "r-tooltip", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[r-tooltip-content]"], true, never>;
+}

package/core/components/tree/shared/components/tree-node/tree-node.component.d.ts

@@ -0,0 +1,43 @@
+import { CdkDrag } from '@angular/cdk/drag-drop';
+import { OnInit } from '@angular/core';
+import { Tree } from '../../../tree.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/drag-drop";
+/**
+ * Represents a tree node component that can be extended, collapsed,
+ * and optionally supports drag-and-drop functionality.
+ */
+export declare class TreeNode implements OnInit {
+    /**
+     * Indicates whether the node is extended (expanded).
+     */
+    readonly extended: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Reference to the `CdkDrag` directive for drag-and-drop functionality.
+     */
+    protected node: CdkDrag<any>;
+    /**
+     * Reference to a nested `Tree` component, if present.
+     */
+    readonly nestedTree: import("@angular/core").Signal<Tree | undefined>;
+    /**
+     * Emits an event when the node is closed.
+     */
+    closeEmitter: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * Lifecycle hook that is called after the component is initialized.
+     */
+    ngOnInit(): void;
+    /**
+     * Updates the disabled state of the node.
+     * @param disabled - Whether the node should be disabled.
+     */
+    handleNodeDisability(disabled: boolean): void;
+    /**
+     * Toggles the extended (expanded) state of the node.
+     * Emits a close event if the node is collapsed and contains a nested tree.
+     */
+    handleExtension(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNode, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNode, "r-tree-node", never, { "extended": { "alias": "extended"; "required": false; "isSignal": true; }; }, { "extended": "extendedChange"; "closeEmitter": "closeEmitter"; }, ["nestedTree"], ["*", "r-tree"], true, [{ directive: typeof i1.CdkDrag; inputs: { "cdkDragDisabled": "disabled"; }; outputs: {}; }]>;
+}

package/core/components/tree/tree.component.d.ts

@@ -0,0 +1,56 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/drag-drop";
+/**
+ * Represents a tree component that supports drag-and-drop functionality
+ * and manages nested tree nodes.
+ */
+export declare class Tree implements OnInit {
+    /**
+     * The ID of the tree component.
+     */
+    readonly maxWidth: import("@angular/core").InputSignal<string>;
+    /**
+     * Determines whether the tree is draggable.
+     */
+    readonly draggable: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Reference to the `CdkDropList` directive used for drag-and-drop.
+     */
+    private tree;
+    /**
+     * Collection of nested `TreeNode` components.
+     */
+    private readonly nestedNodes;
+    /**
+     * Determines whether to close nodes recursively.
+     */
+    readonly closeRecursively: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Emits an event when a drop occurs in the tree.
+     */
+    dropEmitter: import("@angular/core").OutputEmitterRef<CdkDragDrop<string[], string[], any>>;
+    /**
+     * Initializes the `Tree` component and sets up reactive effects.
+     */
+    constructor();
+    /**
+     * Lifecycle hook that is called after the component is initialized.
+     */
+    ngOnInit(): void;
+    /**
+     * Updates the disabled state of the tree and its nested nodes.
+     */
+    private handleTreeDisability;
+    /**
+     * Sets up recursive closing behavior for nested nodes.
+     */
+    handleCloseRecursively(): void;
+    /**
+     * Closes all nested nodes recursively.
+     */
+    closeNestedNodes(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Tree, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Tree, "r-tree", never, { "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "closeRecursively": { "alias": "closeRecursively"; "required": false; "isSignal": true; }; }, { "dropEmitter": "dropEmitter"; }, ["nestedNodes"], ["*"], true, [{ directive: typeof i1.CdkDropList; inputs: { "id": "id"; "cdkDropListConnectedTo": "connectedTo"; }; outputs: { "cdkDropListDropped": "cdkDropListDropped"; }; }, { directive: typeof i1.CdkDropListGroup; inputs: {}; outputs: {}; }]>;
+}

package/core/directives/in-viewport.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import { InViewportService } from '../services/in-viewport.service';
+import * as i0 from "@angular/core";
+export declare class InViewportDirective implements OnDestroy {
+    readonly inViewportId: import("@angular/core").InputSignal<string>;
+    readonly inViewportInitialVisibility: import("@angular/core").InputSignal<boolean>;
+    el: ElementRef<any>;
+    inViewportService: InViewportService;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InViewportDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InViewportDirective, "[r-in-viewport]", never, { "inViewportId": { "alias": "inViewportId"; "required": true; "isSignal": true; }; "inViewportInitialVisibility": { "alias": "inViewportInitialVisibility"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/core/services/in-viewport.service.d.ts

@@ -0,0 +1,23 @@
+import * as i0 from "@angular/core";
+export declare class InViewportService {
+    readonly elements: import("@angular/core").WritableSignal<Record<string, boolean>>;
+    observer: IntersectionObserver;
+    /**
+     * Register an element to be tracked by the service.
+     * @param {string} id - The id of the element to register.
+     */
+    registerElement(id: string, nativeElement: HTMLElement, initialVisibility: boolean): void;
+    /**
+     * Unregister an element from being tracked by the service.
+     * @param {string} id - The id of the element to unregister.
+     */
+    unregisterElement(id: string): void;
+    /**
+     * Update the visibility of an element.
+     * @param {string} id - The id of the element to update.
+     * @param {boolean} isVisible - The new visibility state of the element.
+     */
+    updateElementVisibility(id: string, isVisible: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InViewportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InViewportService>;
+}

package/core/services/responsive.service.d.ts

@@ -0,0 +1,47 @@
+import * as i0 from "@angular/core";
+/**
+ * Interface that defines the breakpoints for different device types
+ */
+export interface DeviceBreakpoints {
+    /** Maximum width for mobile devices in pixels */
+    mobile: number;
+    /** Maximum width for tablet devices in pixels */
+    tablet: number;
+    /** Maximum width for desktop devices in pixels */
+    desktop: number;
+}
+/** Available device types */
+export type DeviceType = 'mobile' | 'tablet' | 'desktop';
+/**
+ * Service that handles responsive design functionality
+ * Detects current device type based on window width and configurable breakpoints
+ */
+export declare class ResponsiveService {
+    /** Signal that holds the breakpoint configuration */
+    private readonly breakpoints;
+    /** Signal that holds the current window width */
+    private readonly windowWidth;
+    /**
+     * Computed signal that returns the current device type based on window width
+     * @returns The current device type ('mobile', 'tablet', or 'desktop')
+     */
+    readonly currentDevice: import("@angular/core").Signal<DeviceType>;
+    constructor();
+    /**
+     * Initializes the window width signal with the current window inner width
+     * Only called in browser environment
+     */
+    private initializeWindowWidth;
+    /**
+     * Sets up the resize event listener to update window width
+     * Only called in browser environment
+     */
+    private setupResizeListener;
+    /**
+     * Updates the breakpoint configuration
+     * @param newBreakpoints - Partial breakpoint configuration to update
+     */
+    updateBreakpoints(newBreakpoints: Partial<DeviceBreakpoints>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsiveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResponsiveService>;
+}