@radix-ng/primitives 0.34.0 → 0.36.0

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

@@ -85,9 +85,9 @@ export declare class RdxCalendarRootDirective implements AfterViewInit {
      * The days of the week
      */
     readonly weekDays: import("@angular/core").ModelSignal<string[] | undefined>;
-    protected readonly fixedWeeksRef: import("@angular/core").WritableSignal<boolean>;
-    protected readonly disabledRef: import("@angular/core").WritableSignal<boolean>;
-    protected readonly pagedNavigationRef: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _fixedWeeks: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _disabled: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _pagedNavigation: import("@angular/core").WritableSignal<boolean>;
     /**
      * @ignore
      */

package/core/index.d.ts

@@ -1,7 +1,9 @@
 export * from './src/accessor/provide-value-accessor';
 export * from './src/auto-focus.directive';
+export * from './src/clamp';
 export * from './src/document';
 export * from './src/focus-initial.directive';
+export * from './src/getActiveElement';
 export * from './src/id-generator';
 export * from './src/inject-ng-control';
 export * from './src/is-client';
@@ -9,6 +11,7 @@ export * from './src/is-inside-form';
 export * from './src/is-nullish';
 export * from './src/is-number';
 export * from './src/kbd-constants';
+export * from './src/provide-token';
 export * from './src/window';
 export * from './src/date-time';
 export * from './src/positioning/constants';

package/core/src/accessor/provide-value-accessor.d.ts

@@ -9,4 +9,4 @@ import { Provider, Type } from '@angular/core';
  * export class ExampleDirective{}
  * ```
  */
-export declare function provideValueAccessor(type: Type<never>): Provider;
+export declare function provideValueAccessor<T>(type: Type<T>): Provider;

package/core/src/clamp.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The `clamp` function restricts a number within a specified range by returning the value itself if it
+ * falls within the range, or the closest boundary value if it exceeds the range.
+ * @param {number} value - The `value` parameter represents the number that you want to clamp within
+ * the specified range defined by `min` and `max` values.
+ * @param {number} min - If the `value` parameter is less than the `min` value, the
+ * function will return the `min` value.
+ * @param {number} max - If the `value` parameter is greater than the `max` value,
+ * the function will return `max`.
+ * @returns The `clamp` function returns the value of `value` constrained within the range defined by
+ * `min` and `max`.
+ */
+export declare function clamp(value: number, min?: number, max?: number): number;
+/**
+ * The function `roundToStepPrecision` rounds a number to a specified precision step.
+ * @param {number} value - The `value` parameter is the number that you want to round to a specific
+ * precision based on the `step` parameter.
+ * @param {number} step - The `step` parameter in the `roundToStepPrecision` function represents the
+ * interval at which you want to round the `value`. For example, if `step` is 0.5, the `value` will be
+ * rounded to the nearest half.
+ * @returns the `roundedValue` after rounding it to the precision specified by the `step`.
+ */
+export declare function roundToStepPrecision(value: number, step: number): number;
+/**
+ * The function `snapValueToStep` snaps a given value to the nearest step within a specified range.
+ * @param {number} value - The `value` parameter represents the number that you want to snap to the
+ * nearest step value.
+ * @param {number | undefined} min - The `min` parameter represents the minimum value that the `value`
+ * should be snapped to. If `value` is less than `min`, it will be snapped to `min`. If `min` is not
+ * provided (undefined), then the snapping will not consider a minimum value.
+ * @param {number | undefined} max - The `max` parameter represents the maximum value that the `value`
+ * should be snapped to. It ensures that the snapped value does not exceed this maximum value.
+ * @param {number} step - The `step` parameter in the `snapValueToStep` function represents the
+ * interval at which the `value` should be snapped to. It determines the granularity of the snapping
+ * operation. For example, if `step` is 5, the `value` will be snapped to the nearest multiple of
+ * @returns a number that has been snapped to the nearest step value within the specified range of minimum and maximum values.
+ */
+export declare function snapValueToStep(value: number, min: number | undefined, max: number | undefined, step: number): number;

package/core/src/date-time/index.d.ts

@@ -1,6 +1,9 @@
 export * from './calendar';
 export * from './comparators';
 export * from './formatter';
+export * from './parser';
 export * from './placeholders';
+export * from './segment';
 export * from './types';
+export * from './useDateField';
 export * from './utils';

package/core/src/date-time/parser.d.ts

@@ -0,0 +1,37 @@
+import { InputSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { Granularity } from './comparators';
+import { Formatter } from './formatter';
+import { HourCycle, SegmentContentObj, SegmentPart, SegmentValueObj } from './types';
+type SyncDateSegmentValuesProps = {
+    value: DateValue;
+    formatter: Formatter;
+};
+type SyncTimeSegmentValuesProps = {
+    value: DateValue;
+    formatter: Formatter;
+};
+export declare function syncTimeSegmentValues(props: SyncTimeSegmentValuesProps): SegmentValueObj;
+export declare function initializeSegmentValues(granularity: Granularity): SegmentValueObj;
+type SharedContentProps = {
+    granularity: Granularity;
+    dateRef: DateValue;
+    formatter: Formatter;
+    hideTimeZone: boolean;
+    hourCycle: HourCycle;
+    isTimeValue?: boolean;
+};
+type CreateContentObjProps = SharedContentProps & {
+    segmentValues: SegmentValueObj;
+    locale: InputSignal<string>;
+};
+export declare function syncSegmentValues(props: SyncDateSegmentValuesProps): SegmentValueObj;
+type CreateContentProps = CreateContentObjProps;
+export declare function createContent(props: CreateContentProps): {
+    obj: SegmentContentObj;
+    arr: {
+        part: SegmentPart;
+        value: string;
+    }[];
+};
+export {};

package/core/src/date-time/parts.d.ts

@@ -0,0 +1,12 @@
+import type { DateSegmentPart, EditableSegmentPart, SegmentPart, TimeSegmentPart } from './types';
+export declare const DATE_SEGMENT_PARTS: readonly ["day", "month", "year"];
+export declare const TIME_SEGMENT_PARTS: readonly ["hour", "minute", "second", "dayPeriod"];
+export declare const NON_EDITABLE_SEGMENT_PARTS: readonly ["literal", "timeZoneName"];
+export declare const EDITABLE_SEGMENT_PARTS: readonly ["day", "month", "year", "hour", "minute", "second", "dayPeriod"];
+export declare const EDITABLE_TIME_SEGMENT_PARTS: readonly ["hour", "minute", "second", "dayPeriod"];
+export declare const ALL_SEGMENT_PARTS: readonly ["day", "month", "year", "hour", "minute", "second", "dayPeriod", "literal", "timeZoneName"];
+export declare const ALL_EXCEPT_LITERAL_PARTS: ("day" | "month" | "year" | "hour" | "minute" | "second" | "dayPeriod" | "timeZoneName")[];
+export declare function isDateSegmentPart(part: unknown): part is DateSegmentPart;
+export declare function isTimeSegmentPart(part: unknown): part is TimeSegmentPart;
+export declare function isSegmentPart(part: string): part is EditableSegmentPart;
+export declare function isAnySegmentPart(part: unknown): part is SegmentPart;

package/core/src/date-time/segment.d.ts

@@ -0,0 +1,4 @@
+export declare function isSegmentNavigationKey(key: string): boolean;
+export declare function isNumberString(value: string): boolean;
+export declare function isAcceptableSegmentKey(key: string): boolean;
+export declare function getSegmentElements(parentElement: HTMLElement): Element[];

package/core/src/date-time/types.d.ts

@@ -1,6 +1,7 @@
 import type { DateValue } from '@internationalized/date';
+import { DATE_SEGMENT_PARTS, EDITABLE_SEGMENT_PARTS, NON_EDITABLE_SEGMENT_PARTS, TIME_SEGMENT_PARTS } from './parts';
 export type DateMatcher = (date: DateValue) => boolean;
-export type HourCycle = 12 | 24;
+export type HourCycle = 12 | 24 | undefined;
 export type Month<T> = {
     /**
      * A `DateValue` used to represent the month. Since days
@@ -26,3 +27,19 @@ export type Month<T> = {
      */
     dates: T[];
 };
+export type DateSegmentPart = (typeof DATE_SEGMENT_PARTS)[number];
+export type TimeSegmentPart = (typeof TIME_SEGMENT_PARTS)[number];
+export type EditableSegmentPart = (typeof EDITABLE_SEGMENT_PARTS)[number];
+export type NonEditableSegmentPart = (typeof NON_EDITABLE_SEGMENT_PARTS)[number];
+export type SegmentPart = EditableSegmentPart | NonEditableSegmentPart;
+export type AnyExceptLiteral = Exclude<SegmentPart, 'literal'>;
+export type DayPeriod = 'AM' | 'PM' | null;
+export type DateSegmentObj = {
+    [K in DateSegmentPart]: number | null;
+};
+export type TimeSegmentObj = {
+    [K in TimeSegmentPart]: K extends 'dayPeriod' ? DayPeriod : number | null;
+};
+export type DateAndTimeSegmentObj = DateSegmentObj & TimeSegmentObj;
+export type SegmentValueObj = DateSegmentObj | DateAndTimeSegmentObj;
+export type SegmentContentObj = Record<EditableSegmentPart, string>;

package/core/src/date-time/useDateField.d.ts

@@ -0,0 +1,141 @@
+import { InputSignal, ModelSignal, WritableSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { Formatter } from './formatter';
+import { HourCycle, SegmentPart, SegmentValueObj } from './types';
+export type UseDateFieldProps = {
+    hasLeftFocus: WritableSignal<boolean>;
+    lastKeyZero: WritableSignal<boolean>;
+    placeholder: ModelSignal<DateValue>;
+    hourCycle: HourCycle;
+    formatter: Formatter;
+    segmentValues: WritableSignal<SegmentValueObj>;
+    disabled: InputSignal<boolean>;
+    readonly: InputSignal<boolean>;
+    part: SegmentPart;
+    modelValue: ModelSignal<DateValue | undefined>;
+    focusNext: () => void;
+};
+type SegmentAttrProps = {
+    disabled: boolean;
+    segmentValues: SegmentValueObj;
+    hourCycle: HourCycle;
+    placeholder: DateValue;
+    formatter: Formatter;
+};
+declare function daySegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function monthSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    contenteditable: boolean;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function yearSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function hourSegmentAttrs(props: SegmentAttrProps): {};
+declare function minuteSegmentAttrs(props: SegmentAttrProps): {};
+declare function secondSegmentAttrs(props: SegmentAttrProps): {};
+declare function dayPeriodSegmentAttrs(props: SegmentAttrProps): {};
+declare function literalSegmentAttrs(_props: SegmentAttrProps): {
+    'aria-hidden': boolean;
+    'data-segment': string;
+};
+declare function timeZoneSegmentAttrs(props: SegmentAttrProps): {
+    role: string;
+    'aria-label': string;
+    'data-readonly': boolean;
+    'data-segment': string;
+    tabindex: number | undefined;
+    style: string;
+};
+declare function eraSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': unknown;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+export declare const segmentBuilders: {
+    day: {
+        attrs: typeof daySegmentAttrs;
+    };
+    month: {
+        attrs: typeof monthSegmentAttrs;
+    };
+    year: {
+        attrs: typeof yearSegmentAttrs;
+    };
+    hour: {
+        attrs: typeof hourSegmentAttrs;
+    };
+    minute: {
+        attrs: typeof minuteSegmentAttrs;
+    };
+    second: {
+        attrs: typeof secondSegmentAttrs;
+    };
+    dayPeriod: {
+        attrs: typeof dayPeriodSegmentAttrs;
+    };
+    literal: {
+        attrs: typeof literalSegmentAttrs;
+    };
+    timeZoneName: {
+        attrs: typeof timeZoneSegmentAttrs;
+    };
+    era: {
+        attrs: typeof eraSegmentAttrs;
+    };
+};
+export declare function useDateField(props: UseDateFieldProps): {
+    handleSegmentClick: (e: MouseEvent) => void;
+    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    attributes: import("@angular/core").Signal<{}>;
+};
+export {};

package/core/src/date-time/utils.d.ts

@@ -1 +1,4 @@
+import { Granularity } from './comparators';
+import { HourCycle } from './types';
+export declare function getOptsByGranularity(granularity: Granularity, hourCycle: HourCycle, isTimeValue?: boolean): Intl.DateTimeFormatOptions;
 export declare function handleCalendarInitialFocus(calendar: HTMLElement): void;

package/core/src/getActiveElement.d.ts

@@ -0,0 +1 @@
+export declare function getActiveElement(): Element | null;

package/core/src/provide-token.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+/**
+ * Creates an Angular provider that binds the given token to the existing instance
+ * of the specified class. This is especially useful when you want multiple
+ * tokens (or interfaces) to resolve to the same directive/component instance.
+ *
+ * @template T - The type associated with the injection token.
+ * @param token - The InjectionToken or abstract type you want to provide.
+ * @param type  - The class type whose existing instance will be used for this token.
+ * @returns A Provider configuration object for Angular's DI system.
+ *
+ * @example
+ *
+ * @Directive({
+ *   providers: [
+ *     provideToken(RdxToggleGroupToken, RdxToggleGroupDirective),
+ *     provideValueAccessor(RdxToggleGroupDirective)
+ *   ]
+ * })
+ * export class RdxToggleGroupDirective {}
+ */
+export declare function provideToken<T>(token: InjectionToken<T>, type: Type<unknown>): Provider;

package/date-field/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/date-field

package/date-field/index.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/date-field-root.directive";
+import * as i2 from "./src/date-field-input.directive";
+export * from './src/date-field-context.token';
+export * from './src/date-field-input.directive';
+export * from './src/date-field-root.directive';
+export declare class RdxDateFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDateFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxDateFieldModule, never, [typeof i1.RdxDateFieldRootDirective, typeof i2.RdxDateFieldInputDirective], [typeof i1.RdxDateFieldRootDirective, typeof i2.RdxDateFieldInputDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxDateFieldModule>;
+}

package/date-field/src/date-field-context.token.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken, InputSignal, ModelSignal, Signal, WritableSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { Formatter, HourCycle, SegmentValueObj } from '@radix-ng/primitives/core';
+export interface DateFieldContextToken {
+    locale: InputSignal<string>;
+    value: ModelSignal<DateValue | undefined>;
+    disabled: InputSignal<boolean>;
+    readonly: InputSignal<boolean>;
+    isInvalid: Signal<boolean>;
+    placeholder: ModelSignal<DateValue>;
+    hourCycle: InputSignal<HourCycle>;
+    formatter: Formatter;
+    segmentValues: WritableSignal<SegmentValueObj>;
+    focusNext: () => void;
+    setFocusedElement: (el: HTMLElement) => void;
+}
+export declare const DATE_FIELDS_ROOT_CONTEXT: InjectionToken<DateFieldContextToken>;
+export declare function injectDateFieldsRootContext(): DateFieldContextToken;

package/date-field/src/date-field-input.directive.d.ts

@@ -0,0 +1,53 @@
+import { ElementRef } from '@angular/core';
+import { SegmentPart } from '@radix-ng/primitives/core';
+import * as i0 from "@angular/core";
+export declare class RdxDateFieldInputDirective {
+    private el;
+    private readonly rootContext;
+    /**
+     * The part of the date to render
+     * `'day' | 'month' | 'year' | 'hour' | 'minute' | 'second' | 'dayPeriod' | 'literal' | 'timeZoneName'`
+     */
+    readonly part: import("@angular/core").InputSignal<SegmentPart | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly readonly: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly hasLeftFocus: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly lastKeyZero: import("@angular/core").WritableSignal<boolean>;
+    private readonly fieldData;
+    private readonly attributes;
+    /**
+     * @ignore
+     */
+    handleSegmentClick: (e: MouseEvent) => void;
+    /**
+     * @ignore
+     */
+    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    constructor(el: ElementRef);
+    /**
+     * @ignore
+     */
+    onFocus(e: FocusEvent): void;
+    /**
+     * @ignore
+     */
+    onFocusOut(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDateFieldInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDateFieldInputDirective, "[rdxDateFieldInput]", never, { "part": { "alias": "part"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/date-field/src/date-field-root.directive.d.ts

@@ -0,0 +1,126 @@
+import { Direction } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { AfterViewInit, OnInit } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { DateMatcher, Formatter, Granularity, HourCycle, SegmentValueObj } from '@radix-ng/primitives/core';
+import * as i0 from "@angular/core";
+export declare class RdxDateFieldRootDirective implements OnInit, AfterViewInit {
+    private readonly elementRef;
+    /**
+     * The controlled checked state of the calendar.
+     */
+    readonly value: import("@angular/core").ModelSignal<DateValue | undefined>;
+    /**
+     * A callback fired when the date field's value is invalid.
+     */
+    readonly isDateUnavailable: import("@angular/core").InputSignal<DateMatcher | undefined>;
+    /**
+     * The hour cycle to use for formatting times. Defaults to the locale preference
+     */
+    readonly hourCycle: import("@angular/core").InputSignal<HourCycle>;
+    /**
+     * The granularity to use for formatting the field. Defaults to 'day' if a CalendarDate is provided, otherwise defaults to 'minute'.
+     * The field will render segments for each part of the date up to and including the specified granularity.
+     */
+    readonly granularity: import("@angular/core").InputSignal<Granularity | undefined>;
+    /**
+     * The locale to use for formatting dates.
+     */
+    readonly locale: import("@angular/core").InputSignal<string>;
+    readonly dir: import("@angular/core").InputSignal<Direction>;
+    /**
+     * The minimum valid date that can be entered.
+     */
+    readonly minValue: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * The maximum valid date that can be entered.
+     */
+    readonly maxValue: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * Whether or not to hide the time zone segment of the field.
+     */
+    readonly hideTimeZone: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether or not the field is readonly.
+     */
+    readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @ignore
+     */
+    readonly defaultDate: import("@angular/core").Signal<DateValue>;
+    /**
+     * The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view
+     */
+    readonly placeholder: import("@angular/core").ModelSignal<DateValue | undefined>;
+    /**
+     * @ignore
+     */
+    readonly segmentElements: import("@angular/core").WritableSignal<Set<HTMLElement>>;
+    /**
+     * @ignore
+     */
+    readonly currentFocusedElement: import("@angular/core").WritableSignal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    formatter: Formatter;
+    /**
+     * @ignore
+     */
+    readonly segmentValues: import("@angular/core").WritableSignal<SegmentValueObj>;
+    /**
+     * @ignore
+     */
+    readonly inferredGranularity: import("@angular/core").Signal<Granularity | undefined>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly allSegmentContent: import("@angular/core").Signal<{
+        obj: import("@radix-ng/primitives/core").SegmentContentObj;
+        arr: {
+            part: import("@radix-ng/primitives/core").SegmentPart;
+            value: string;
+        }[];
+    }>;
+    /**
+     * An array of segments that should be readonly, which prevent user input on them.
+     */
+    readonly segmentContents: import("@angular/core").Signal<{
+        part: import("@radix-ng/primitives/core").SegmentPart;
+        value: string;
+    }[]>;
+    /**
+     * @ignore
+     */
+    readonly currentSegmentIndex: import("@angular/core").Signal<number>;
+    /**
+     * @ignore
+     */
+    readonly prevFocusableSegment: import("@angular/core").Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly nextFocusableSegment: import("@angular/core").Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly focusNext: () => void;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * @ignore
+     */
+    setFocusedElement(el: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDateFieldRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDateFieldRootDirective, "[rdxDateFieldRoot]", ["rdxDateFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, never, never, true, never>;
+}

package/dialog/src/dialog-ref.d.ts

@@ -10,6 +10,9 @@ export declare const DISMISSED_VALUE: {};
 export declare class RdxDialogRef<C = unknown> {
     readonly cdkRef: DialogRef<RdxDialogResult<C> | typeof DISMISSED_VALUE, C>;
     readonly config: RdxDialogConfig<C>;
+    private _previousTimeout;
+    private readonly _openSignal;
+    readonly state: import("@angular/core").Signal<"open" | "closed">;
     closed$: Observable<RdxDialogResult<C> | undefined>;
     dismissed$: Observable<void>;
     result$: Observable<RdxDialogResult<C>>;

package/dialog/src/dialog.config.d.ts

@@ -26,6 +26,7 @@ type RdxBaseDialogConfig<C> = {
     autoFocus?: AutoFocusTarget | 'first-input' | string;
     canClose?: (comp: C) => boolean | Observable<boolean>;
     canCloseWithBackdrop?: boolean;
+    closeDelay?: number;
     cdkConfigOverride?: Partial<DialogConfig<C>>;
     mode?: RdxDialogMode;
     backdropClass?: string | string[];

package/fesm2022/radix-ng-primitives-calendar.mjs

@@ -744,18 +744,9 @@ class RdxCalendarRootDirective {
          * The days of the week
          */
         this.weekDays = model();
-        this.fixedWeeksRef = linkedSignal({
-            source: this.fixedWeeks,
-            computation: (value) => value
-        });
-        this.disabledRef = linkedSignal({
-            source: this.disabled,
-            computation: (value) => value
-        });
-        this.pagedNavigationRef = linkedSignal({
-            source: this.pagedNavigation,
-            computation: (value) => value
-        });
+        this._fixedWeeks = linkedSignal(this.fixedWeeks);
+        this._disabled = linkedSignal(this.disabled);
+        this._pagedNavigation = linkedSignal(this.pagedNavigation);
         /**
          * @ignore
          */
@@ -768,13 +759,13 @@ class RdxCalendarRootDirective {
             locale: this.locale,
             placeholder: this.placeholder,
             weekStartsOn: this.weekStartsOn,
-            fixedWeeks: this.fixedWeeksRef,
+            fixedWeeks: this._fixedWeeks,
             numberOfMonths: this.numberOfMonths,
             minValue: this.minValue,
             maxValue: this.maxValue,
-            disabled: this.disabledRef,
+            disabled: this._disabled,
             weekdayFormat: this.weekdayFormat,
-            pagedNavigation: this.pagedNavigationRef,
+            pagedNavigation: this._pagedNavigation,
             isDateDisabled: this.isDateDisabled,
             isDateUnavailable: this.isDateUnavailable,
             calendarLabel: this.calendarLabel,