@radix-ng/primitives 0.16.0 → 0.18.0

package/slider/src/slider-thumb-impl.directive.d.ts

@@ -0,0 +1,26 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { RdxSliderRootComponent } from './slider-root.component';
+import * as i0 from "@angular/core";
+export declare class RdxSliderThumbImplDirective implements OnInit, OnDestroy {
+    protected readonly rootContext: RdxSliderRootComponent;
+    private readonly elementRef;
+    private resizeObserver;
+    isMounted: import("@angular/core").WritableSignal<boolean>;
+    thumbIndex: import("@angular/core").Signal<number | null>;
+    value: import("@angular/core").Signal<number | undefined>;
+    percent: import("@angular/core").Signal<number>;
+    transform: import("@angular/core").Signal<string>;
+    orientationSize: import("@angular/core").WritableSignal<number>;
+    thumbInBoundsOffset: import("@angular/core").Signal<number>;
+    combinedStyles: import("@angular/core").Signal<{
+        [x: string]: string | undefined;
+        position: string;
+        transform: string;
+        display: string | undefined;
+    }>;
+    onFocus(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSliderThumbImplDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSliderThumbImplDirective, "[rdxSliderThumbImpl]", never, {}, {}, never, never, true, never>;
+}

package/slider/src/slider-thumb.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./slider-thumb-impl.directive";
+export declare class RdxSliderThumbComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSliderThumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxSliderThumbComponent, "rdx-slider-thumb", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.RdxSliderThumbImplDirective; inputs: {}; outputs: {}; }]>;
+}

package/slider/src/slider-track.component.d.ts

@@ -0,0 +1,7 @@
+import { RdxSliderRootComponent } from './slider-root.component';
+import * as i0 from "@angular/core";
+export declare class RdxSliderTrackComponent {
+    protected readonly rootContext: RdxSliderRootComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSliderTrackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxSliderTrackComponent, "rdx-slider-track", never, {}, {}, never, ["*"], true, never>;
+}

package/slider/src/slider-vertical.component.d.ts

@@ -0,0 +1,29 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class RdxSliderVerticalComponent {
+    private readonly rootContext;
+    dir: 'ltr' | 'rtl';
+    readonly inverted: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    min: number;
+    max: number;
+    className: string;
+    slideStart: EventEmitter<number>;
+    slideMove: EventEmitter<number>;
+    slideEnd: EventEmitter<void>;
+    stepKeyDown: EventEmitter<{
+        event: KeyboardEvent;
+        direction: number;
+    }>;
+    endKeyDown: EventEmitter<KeyboardEvent>;
+    homeKeyDown: EventEmitter<KeyboardEvent>;
+    private readonly sliderElement;
+    private readonly rect;
+    onSlideStart(event: PointerEvent): void;
+    onSlideMove(event: PointerEvent): void;
+    onSlideEnd(): void;
+    onStepKeyDown(event: KeyboardEvent): void;
+    private getValueFromPointer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSliderVerticalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxSliderVerticalComponent, "rdx-slider-vertical", never, { "dir": { "alias": "dir"; "required": false; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "slideStart": "slideStart"; "slideMove": "slideMove"; "slideEnd": "slideEnd"; "stepKeyDown": "stepKeyDown"; "endKeyDown": "endKeyDown"; "homeKeyDown": "homeKeyDown"; }, never, ["*"], true, never>;
+}

package/slider/src/utils.d.ts

@@ -0,0 +1,52 @@
+export declare function linearScale(input: readonly [number, number], output: readonly [number, number]): (value: number) => number;
+/**
+ * Verifies the minimum steps between all values is greater than or equal
+ * to the expected minimum steps.
+ *
+ * @example
+ * // returns false
+ * hasMinStepsBetweenValues([1,2,3], 2);
+ *
+ * @example
+ * // returns true
+ * hasMinStepsBetweenValues([1,2,3], 1);
+ */
+export declare function hasMinStepsBetweenValues(values: number[], minStepsBetweenValues: number): boolean;
+/**
+ * Given a `values` array and a `nextValue`, determine which value in
+ * the array is closest to `nextValue` and return its index.
+ *
+ * @example
+ * // returns 1
+ * getClosestValueIndex([10, 30], 25);
+ */
+export declare function getClosestValueIndex(values: number[], nextValue: number): number;
+/**
+ * Gets an array of steps between each value.
+ *
+ * @example
+ * // returns [1, 9]
+ * getStepsBetweenValues([10, 11, 20]);
+ */
+export declare function getStepsBetweenValues(values: number[]): number[];
+/**
+ * Offsets the thumb centre point while sliding to ensure it remains
+ * within the bounds of the slider when reaching the edges
+ */
+export declare function getThumbInBoundsOffset(width: number, left: number, direction: number): number;
+export declare function convertValueToPercentage(value: number, min: number, max: number): number;
+export declare function getDecimalCount(value: number): number;
+export declare function roundValue(value: number, decimalCount: number): number;
+export declare function getNextSortedValues(prevValues: number[] | undefined, nextValue: number, atIndex: number): number[];
+export declare const PAGE_KEYS: string[];
+export declare const ARROW_KEYS: string[];
+type SlideDirection = 'from-left' | 'from-right' | 'from-bottom' | 'from-top';
+export declare const BACK_KEYS: Record<SlideDirection, string[]>;
+export interface OrientationContext {
+    direction: number;
+    size: 'width' | 'height';
+    startEdge: 'left' | 'top';
+    endEdge: 'right' | 'bottom';
+}
+export declare function clamp(value: number, min?: number, max?: number): number;
+export {};

package/tooltip/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/tooltip

package/tooltip/index.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/tooltip-arrow.directive";
+import * as i2 from "./src/tooltip-content.directive";
+import * as i3 from "./src/tooltip-trigger.directive";
+import * as i4 from "./src/tooltip-content-attributes.directive";
+import * as i5 from "./src/tooltip-root.directive";
+export * from './src/tooltip-arrow.directive';
+export * from './src/tooltip-content-attributes.directive';
+export * from './src/tooltip-content.directive';
+export * from './src/tooltip-root.directive';
+export * from './src/tooltip-trigger.directive';
+export * from './src/tooltip.types';
+export declare class RdxTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxTooltipModule, never, [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipContentDirective, typeof i3.RdxTooltipTriggerDirective, typeof i4.RdxTooltipContentAttributesDirective, typeof i5.RdxTooltipRootDirective], [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipContentDirective, typeof i3.RdxTooltipTriggerDirective, typeof i4.RdxTooltipContentAttributesDirective, typeof i5.RdxTooltipRootDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxTooltipModule>;
+}

package/tooltip/src/get-content-position.d.ts

@@ -0,0 +1,3 @@
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { RdxTooltipAlign, RdxTooltipSide } from './tooltip.types';
+export declare function getContentPosition(side: RdxTooltipSide, align: RdxTooltipAlign, sideOffset: number, alignOffset: number): ConnectedPosition;

package/tooltip/src/tooltip-arrow.directive.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+export declare class RdxTooltipArrowDirective {
+    /** @ignore */
+    private readonly renderer;
+    /** @ignore */
+    private readonly contentDirective;
+    /** @ignore */
+    private readonly elementRef;
+    /**
+     * The width of the arrow in pixels.
+     */
+    readonly width: import("@angular/core").InputSignal<number>;
+    /**
+     * The height of the arrow in pixels.
+     */
+    readonly height: import("@angular/core").InputSignal<number>;
+    /** @ignore */
+    readonly arrowSvgElement: import("@angular/core").Signal<HTMLElement>;
+    /** @ignore */
+    private readonly onArrowSvgElementChangeEffect;
+    /** @ignore */
+    private readonly onSideChangeEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipArrowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipArrowDirective, "[rdxTooltipArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/tooltip/src/tooltip-arrow.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxTooltipArrowDirective } from './tooltip-arrow.directive';
+export declare const RdxTooltipArrowToken: InjectionToken<RdxTooltipArrowDirective>;

package/tooltip/src/tooltip-content-attributes.directive.d.ts

@@ -0,0 +1,8 @@
+import { RdxTooltipRootDirective } from './tooltip-root.directive';
+import * as i0 from "@angular/core";
+export declare class RdxTooltipContentAttributesDirective {
+    readonly tooltipRoot: RdxTooltipRootDirective;
+    readonly tooltipContent: import("@radix-ng/primitives/tooltip").RdxTooltipContentDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipContentAttributesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipContentAttributesDirective, "[rdxTooltipContentAttributes]", never, {}, {}, never, never, true, never>;
+}

package/tooltip/src/tooltip-content.directive.d.ts

@@ -0,0 +1,36 @@
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { TemplateRef } from '@angular/core';
+import { RdxTooltipAlign, RdxTooltipSide } from './tooltip.types';
+import * as i0 from "@angular/core";
+export declare class RdxTooltipContentDirective {
+    /** @ignore */
+    readonly templateRef: TemplateRef<any>;
+    /**
+     * The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
+     */
+    readonly side: import("@angular/core").InputSignal<RdxTooltipSide>;
+    /**
+     * The distance in pixels from the trigger.
+     */
+    readonly sideOffset: import("@angular/core").InputSignal<number>;
+    /**
+     * The preferred alignment against the trigger. May change when collisions occur.
+     */
+    readonly align: import("@angular/core").InputSignal<RdxTooltipAlign>;
+    /**
+     * An offset in pixels from the "start" or "end" alignment options.
+     */
+    readonly alignOffset: import("@angular/core").InputSignal<number>;
+    /** @ingore */
+    readonly position: import("@angular/core").Signal<ConnectedPosition>;
+    /**
+     * Event handler called when the escape key is down. It can be prevented by calling event.preventDefault.
+     */
+    readonly onEscapeKeyDown: import("@angular/core").OutputEmitterRef<KeyboardEvent>;
+    /**
+     * Event handler called when a pointer event occurs outside the bounds of the component. It can be prevented by calling event.preventDefault.
+     */
+    readonly onPointerDownOutside: import("@angular/core").OutputEmitterRef<MouseEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipContentDirective, "[rdxTooltipContent]", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; }, { "onEscapeKeyDown": "onEscapeKeyDown"; "onPointerDownOutside": "onPointerDownOutside"; }, never, never, true, never>;
+}

package/tooltip/src/tooltip-content.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxTooltipContentDirective } from './tooltip-content.directive';
+export declare const RdxTooltipContentToken: InjectionToken<RdxTooltipContentDirective>;

package/tooltip/src/tooltip-root.directive.d.ts

@@ -0,0 +1,103 @@
+import { ElementRef, InjectionToken, OnInit } from '@angular/core';
+import { RdxTooltipState } from './tooltip.types';
+import * as i0 from "@angular/core";
+export declare const RdxTooltipRootToken: InjectionToken<RdxTooltipRootDirective>;
+export declare function injectTooltipRoot(): RdxTooltipRootDirective;
+export declare class RdxTooltipRootDirective implements OnInit {
+    /** @ignore */
+    private readonly viewContainerRef;
+    /** @ignore */
+    private readonly destroyRef;
+    /** @ignore */
+    private readonly overlay;
+    /** @ignore */
+    private readonly platformId;
+    /** @ignore */
+    private readonly document;
+    /** @ignore */
+    readonly tooltipConfig: import("./tooltip.types").RdxTooltipConfig;
+    /**
+     * The open state of the tooltip when it is initially rendered. Use when you do not need to control its open state.
+     */
+    readonly defaultOpen: import("@angular/core").InputSignal<boolean>;
+    /**
+     * The controlled open state of the tooltip. Must be used in conjunction with onOpenChange.
+     */
+    readonly open: import("@angular/core").InputSignal<boolean | undefined>;
+    /**
+     * Override the duration given to the configuration to customise the open delay for a specific tooltip.
+     */
+    readonly delayDuration: import("@angular/core").InputSignal<number>;
+    /** @ignore */
+    readonly disableHoverableContent: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Event handler called when the open state of the tooltip changes.
+     */
+    readonly onOpenChange: import("@angular/core").OutputEmitterRef<boolean>;
+    /** @ignore */
+    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    /** @ignore */
+    readonly isOpenDelayed: import("@angular/core").WritableSignal<boolean>;
+    /** @ignore */
+    readonly wasOpenDelayed: import("@angular/core").WritableSignal<boolean>;
+    /** @ignore */
+    readonly state: import("@angular/core").Signal<RdxTooltipState>;
+    /** @ignore */
+    readonly tooltipContentDirective: import("@angular/core").Signal<import("@radix-ng/primitives/tooltip").RdxTooltipContentDirective>;
+    /** @ignore */
+    readonly tooltipTriggerElementRef: import("@angular/core").Signal<ElementRef<any>>;
+    /** @ignore */
+    private openTimer;
+    /** @ignore */
+    private skipDelayTimer;
+    /** @ignore */
+    private overlayRef?;
+    /** @ignore */
+    private instance?;
+    /** @ignore */
+    private portal;
+    /** @ignore */
+    private isControlledExternally;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    onTriggerEnter(): void;
+    /** @ignore */
+    onTriggerLeave(): void;
+    /** @ignore */
+    onOpen(): void;
+    /** @ignore */
+    onClose(): void;
+    /** @ignore */
+    handleOpen(): void;
+    /** @ignore */
+    handleClose(): void;
+    /** @ignore */
+    private handleOverlayKeydown;
+    /** @ignore */
+    private handlePointerDownOutside;
+    /** @ignore */
+    private handleDelayedOpen;
+    /** @ignore */
+    private setOpen;
+    /** @ignore */
+    private createOverlayRef;
+    /** @ignore */
+    private show;
+    /** @ignore */
+    private detach;
+    /** @ignore */
+    private hide;
+    /** @ignore */
+    private getPositionStrategy;
+    /** @ignore */
+    private clearTimeout;
+    /** @ignore */
+    private readonly onIsOpenChangeEffect;
+    /** @ignore */
+    private readonly onPositionChangeEffect;
+    /** @ignore */
+    private readonly onOpenChangeEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipRootDirective, "[rdxTooltipRoot]", ["rdxTooltipRoot"], { "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "delayDuration": { "alias": "delayDuration"; "required": false; "isSignal": true; }; "disableHoverableContent": { "alias": "disableHoverableContent"; "required": false; "isSignal": true; }; }, { "onOpenChange": "onOpenChange"; }, ["tooltipContentDirective", "tooltipTriggerElementRef"], never, true, never>;
+}

package/tooltip/src/tooltip-trigger.directive.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class RdxTooltipTriggerDirective {
+    /** @ignore */
+    readonly tooltipRoot: import("./tooltip-root.directive").RdxTooltipRootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** @ignore */
+    private isPointerDown;
+    /** @ignore */
+    private isPointerInside;
+    /** @ignore */
+    onPointerMove(event: PointerEvent): void;
+    /** @ignore */
+    onPointerLeave(): void;
+    /** @ignore */
+    onPointerDown(): void;
+    /** @ignore */
+    onFocus(): void;
+    /** @ignore */
+    onBlur(): void;
+    /** @ignore */
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipTriggerDirective, "[rdxTooltipTrigger]", never, {}, {}, never, never, true, never>;
+}

package/tooltip/src/tooltip.config.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { RdxTooltipConfig } from './tooltip.types';
+export declare const defaultTooltipConfig: RdxTooltipConfig;
+export declare const RdxTooltipConfigToken: InjectionToken<RdxTooltipConfig>;
+export declare function provideRdxTooltipConfig(config: Partial<RdxTooltipConfig>): Provider[];
+export declare function injectTooltipConfig(): RdxTooltipConfig;

package/tooltip/src/tooltip.constants.d.ts

@@ -0,0 +1,9 @@
+import { ConnectionPositionPair } from '@angular/cdk/overlay';
+import { RdxTooltipAlign, RdxTooltipSide } from './tooltip.types';
+type TooltipPositions = {
+    [key in RdxTooltipSide]: {
+        [key in RdxTooltipAlign]: ConnectionPositionPair;
+    };
+};
+export declare const TOOLTIP_POSITIONS: TooltipPositions;
+export {};

package/tooltip/src/tooltip.types.d.ts

@@ -0,0 +1,18 @@
+export declare enum RdxTooltipSide {
+    Top = "top",
+    Right = "right",
+    Bottom = "bottom",
+    Left = "left"
+}
+export declare enum RdxTooltipAlign {
+    Start = "start",
+    Center = "center",
+    End = "end"
+}
+export type RdxTooltipConfig = {
+    delayDuration: number;
+    skipDelayDuration: number;
+    disableHoverableContent?: boolean;
+    hideDelayDuration?: number;
+};
+export type RdxTooltipState = 'delayed-open' | 'instant-open' | 'closed';