@radix-ng/primitives 0.33.1 → 0.34.0

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

@@ -1,8 +1,9 @@
 import { NG_VALUE_ACCESSOR, NgControl, FormControlDirective, FormControlName, NgModel } from '@angular/forms';
 import * as i0 from '@angular/core';
-import { inject, ElementRef, NgZone, booleanAttribute, Input, Directive, APP_ID, Injectable, InjectionToken } from '@angular/core';
+import { inject, ElementRef, NgZone, booleanAttribute, Input, Directive, APP_ID, Injectable, InjectionToken, effect, untracked } from '@angular/core';
 import { DOCUMENT } from '@angular/common';
 import { Platform } from '@angular/cdk/platform';
+import { getLocalTimeZone, CalendarDateTime, ZonedDateTime, getDayOfWeek, DateFormatter, createCalendar, toCalendar, CalendarDate, startOfMonth, endOfMonth, today } from '@internationalized/date';
 
 /**
  * Include in the providers section of a component which utilizes ControlValueAccessor to redundant code.
@@ -236,6 +237,7 @@ const p = 'p';
 const n = 'n';
 const j = 'j';
 const k = 'k';
+const SPACE_CODE = 'Space';
 
 const WINDOW = new InjectionToken('An abstraction over global window object', {
     factory: () => {
@@ -250,6 +252,509 @@ function injectWindow() {
     return inject(WINDOW);
 }
 
+/**
+ * Splits an array into chunks of a given size.
+ * @param arr The array to split.
+ * @param size The size of each chunk.
+ * @returns An array of arrays, where each sub-array has `size` elements from the original array.
+ * @example ```ts
+ * const arr = [1, 2, 3, 4, 5, 6, 7, 8];
+ * const chunks = chunk(arr, 3);
+ * // chunks = [[1, 2, 3], [4, 5, 6], [7, 8]]
+ * ```
+ */
+function chunk(arr, size) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size)
+        result.push(arr.slice(i, i + size));
+    return result;
+}
+
+/**
+ * Given a `DateValue` object, convert it to a native `Date` object.
+ * If a timezone is provided, the date will be converted to that timezone.
+ * If no timezone is provided, the date will be converted to the local timezone.
+ */
+function toDate(dateValue, tz = getLocalTimeZone()) {
+    if (isZonedDateTime(dateValue))
+        return dateValue.toDate();
+    else
+        return dateValue.toDate(tz);
+}
+function isCalendarDateTime(dateValue) {
+    return dateValue instanceof CalendarDateTime;
+}
+function isZonedDateTime(dateValue) {
+    return dateValue instanceof ZonedDateTime;
+}
+function hasTime(dateValue) {
+    return isCalendarDateTime(dateValue) || isZonedDateTime(dateValue);
+}
+/**
+ * Given a date, return the number of days in the month.
+ */
+function getDaysInMonth(date) {
+    if (date instanceof Date) {
+        const year = date.getFullYear();
+        const month = date.getMonth() + 1;
+        /**
+         * By using zero as the day, we get the
+         * last day of the previous month, which
+         * is the month we originally passed in.
+         */
+        return new Date(year, month, 0).getDate();
+    }
+    else {
+        return date.set({ day: 100 }).day;
+    }
+}
+/**
+ * Determine if a date is before the reference date.
+ * @param dateToCompare - is this date before the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` before this date
+ *
+ * @see {@link isBeforeOrSame} for inclusive
+ */
+function isBefore(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) < 0;
+}
+/**
+ * Determine if a date is after the reference date.
+ * @param dateToCompare - is this date after the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` after this date
+ *
+ * @see {@link isAfterOrSame} for inclusive
+ */
+function isAfter(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) > 0;
+}
+/**
+ * Determine if a date is before or the same as the reference date.
+ *
+ * @param dateToCompare - the date to compare
+ * @param referenceDate - the reference date to make the comparison against
+ *
+ * @see {@link isBefore} for non-inclusive
+ */
+function isBeforeOrSame(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) <= 0;
+}
+/**
+ * Determine if a date is after or the same as the reference date.
+ *
+ * @param dateToCompare - is this date after or the same as the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` after or the same as this date
+ *
+ * @see {@link isAfter} for non-inclusive
+ */
+function isAfterOrSame(dateToCompare, referenceDate) {
+    return dateToCompare.compare(referenceDate) >= 0;
+}
+/**
+ * Determine if a date is inclusively between a start and end reference date.
+ *
+ * @param date - is this date inclusively between the `start` and `end` dates
+ * @param start - the start reference date to make the comparison against
+ * @param end - the end reference date to make the comparison against
+ *
+ * @see {@link isBetween} for non-inclusive
+ */
+function isBetweenInclusive(date, start, end) {
+    return isAfterOrSame(date, start) && isBeforeOrSame(date, end);
+}
+/**
+ * Determine if a date is between a start and end reference date.
+ *
+ * @param date - is this date between the `start` and `end` dates
+ * @param start - the start reference date to make the comparison against
+ * @param end - the end reference date to make the comparison against
+ *
+ * @see {@link isBetweenInclusive} for inclusive
+ */
+function isBetween(date, start, end) {
+    return isAfter(date, start) && isBefore(date, end);
+}
+function getLastFirstDayOfWeek(date, firstDayOfWeek, locale) {
+    const day = getDayOfWeek(date, locale);
+    if (firstDayOfWeek > day)
+        return date.subtract({ days: day + 7 - firstDayOfWeek });
+    if (firstDayOfWeek === day)
+        return date;
+    return date.subtract({ days: day - firstDayOfWeek });
+}
+function getNextLastDayOfWeek(date, firstDayOfWeek, locale) {
+    const day = getDayOfWeek(date, locale);
+    const lastDayOfWeek = firstDayOfWeek === 0 ? 6 : firstDayOfWeek - 1;
+    if (day === lastDayOfWeek)
+        return date;
+    if (day > lastDayOfWeek)
+        return date.add({ days: 7 - day + lastDayOfWeek });
+    return date.add({ days: lastDayOfWeek - day });
+}
+function areAllDaysBetweenValid(start, end, isUnavailable, isDisabled) {
+    if (isUnavailable === undefined && isDisabled === undefined)
+        return true;
+    let dCurrent = start.add({ days: 1 });
+    if (isDisabled?.(dCurrent) || isUnavailable?.(dCurrent))
+        return false;
+    const dEnd = end;
+    while (dCurrent.compare(dEnd) < 0) {
+        dCurrent = dCurrent.add({ days: 1 });
+        if (isDisabled?.(dCurrent) || isUnavailable?.(dCurrent))
+            return false;
+    }
+    return true;
+}
+/**
+ * A helper function used throughout the various date builders
+ * to generate a default `DateValue` using the `defaultValue`,
+ * `defaultPlaceholder`, and `granularity` props.
+ *
+ * It's important to match the `DateValue` type being used
+ * elsewhere in the builder, so they behave according to the
+ * behavior the user expects based on the props they've provided.
+ *
+ */
+function getDefaultDate(props) {
+    const { defaultValue, defaultPlaceholder, granularity = 'day', locale = 'en' } = props;
+    if (Array.isArray(defaultValue) && defaultValue.length)
+        return defaultValue[defaultValue.length - 1].copy();
+    if (defaultValue && !Array.isArray(defaultValue))
+        return defaultValue.copy();
+    if (defaultPlaceholder)
+        return defaultPlaceholder.copy();
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const calendarDateTimeGranularities = ['hour', 'minute', 'second'];
+    const defaultFormatter = new DateFormatter(locale);
+    const calendar = createCalendar(defaultFormatter.resolvedOptions().calendar);
+    if (calendarDateTimeGranularities.includes(granularity ?? 'day'))
+        return toCalendar(new CalendarDateTime(year, month, day, 0, 0, 0), calendar);
+    return toCalendar(new CalendarDate(year, month, day), calendar);
+}
+
+/**
+ * Retrieves an array of date values representing the days between
+ * the provided start and end dates.
+ */
+function getDaysBetween(start, end) {
+    const days = [];
+    let dCurrent = start.add({ days: 1 });
+    const dEnd = end;
+    while (dCurrent.compare(dEnd) < 0) {
+        days.push(dCurrent);
+        dCurrent = dCurrent.add({ days: 1 });
+    }
+    return days;
+}
+function createMonth(props) {
+    const { dateObj, weekStartsOn, fixedWeeks, locale } = props;
+    const daysInMonth = getDaysInMonth(dateObj);
+    const datesArray = Array.from({ length: daysInMonth }, (_, i) => dateObj.set({ day: i + 1 }));
+    const firstDayOfMonth = startOfMonth(dateObj);
+    const lastDayOfMonth = endOfMonth(dateObj);
+    const lastSunday = getLastFirstDayOfWeek(firstDayOfMonth, weekStartsOn, locale);
+    const nextSaturday = getNextLastDayOfWeek(lastDayOfMonth, weekStartsOn, locale);
+    const lastMonthDays = getDaysBetween(lastSunday.subtract({ days: 1 }), firstDayOfMonth);
+    const nextMonthDays = getDaysBetween(lastDayOfMonth, nextSaturday.add({ days: 1 }));
+    const totalDays = lastMonthDays.length + datesArray.length + nextMonthDays.length;
+    if (fixedWeeks && totalDays < 42) {
+        const extraDays = 42 - totalDays;
+        let startFrom = nextMonthDays[nextMonthDays.length - 1];
+        if (!startFrom)
+            startFrom = endOfMonth(dateObj);
+        const extraDaysArray = Array.from({ length: extraDays }, (_, i) => {
+            const incr = i + 1;
+            return startFrom.add({ days: incr });
+        });
+        nextMonthDays.push(...extraDaysArray);
+    }
+    const allDays = lastMonthDays.concat(datesArray, nextMonthDays);
+    const weeks = chunk(allDays, 7);
+    return {
+        value: dateObj,
+        dates: allDays,
+        weeks: weeks
+    };
+}
+function createMonths(props) {
+    const { numberOfMonths, dateObj, ...monthProps } = props;
+    const months = [];
+    if (!numberOfMonths || numberOfMonths === 1) {
+        months.push(createMonth({
+            ...monthProps,
+            dateObj
+        }));
+        return months;
+    }
+    months.push(createMonth({
+        ...monthProps,
+        dateObj
+    }));
+    // Create all the months, starting with the current month
+    for (let i = 1; i < numberOfMonths; i++) {
+        const nextMonth = dateObj.add({ months: i });
+        months.push(createMonth({
+            ...monthProps,
+            dateObj: nextMonth
+        }));
+    }
+    return months;
+}
+
+const defaultPartOptions = {
+    year: 'numeric',
+    month: 'numeric',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric'
+};
+/**
+ * Creates a wrapper around the `DateFormatter`, which is
+ * an improved version of the {@link Intl.DateTimeFormat} API,
+ * that is used internally by the various date builders to
+ * easily format dates in a consistent way.
+ *
+ * @see [DateFormatter](https://react-spectrum.adobe.com/internationalized/date/DateFormatter.html)
+ */
+function createFormatter(initialLocale) {
+    let locale = initialLocale;
+    function setLocale(newLocale) {
+        locale = newLocale;
+    }
+    function getLocale() {
+        return locale;
+    }
+    function custom(date, options) {
+        return new DateFormatter(locale, options).format(date);
+    }
+    function selectedDate(date, includeTime = true) {
+        if (hasTime(date) && includeTime) {
+            return custom(toDate(date), {
+                dateStyle: 'long',
+                timeStyle: 'long'
+            });
+        }
+        else {
+            return custom(toDate(date), {
+                dateStyle: 'long'
+            });
+        }
+    }
+    function fullMonthAndYear(date) {
+        return new DateFormatter(locale, { month: 'long', year: 'numeric' }).format(date);
+    }
+    function fullMonth(date) {
+        return new DateFormatter(locale, { month: 'long' }).format(date);
+    }
+    function fullYear(date) {
+        return new DateFormatter(locale, { year: 'numeric' }).format(date);
+    }
+    function toParts(date, options) {
+        if (isZonedDateTime(date)) {
+            return new DateFormatter(locale, {
+                ...options,
+                timeZone: date.timeZone
+            }).formatToParts(toDate(date));
+        }
+        else {
+            return new DateFormatter(locale, options).formatToParts(toDate(date));
+        }
+    }
+    function dayOfWeek(date, length = 'narrow') {
+        return new DateFormatter(locale, { weekday: length }).format(date);
+    }
+    function dayPeriod(date, hourCycle = undefined) {
+        const parts = new DateFormatter(locale, {
+            hour: 'numeric',
+            minute: 'numeric',
+            hourCycle: hourCycle === 24 ? 'h23' : undefined
+        }).formatToParts(date);
+        const value = parts.find((p) => p.type === 'dayPeriod')?.value;
+        if (value === 'PM') {
+            return 'PM';
+        }
+        return 'AM';
+    }
+    function part(dateObj, type, options = {}) {
+        const opts = { ...defaultPartOptions, ...options };
+        const parts = toParts(dateObj, opts);
+        const part = parts.find((p) => p.type === type);
+        return part ? part.value : '';
+    }
+    function getMonths() {
+        const defaultDate = today(getLocalTimeZone());
+        const months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+        return months.map((item) => ({ label: fullMonth(toDate(defaultDate.set({ month: item }))), value: item }));
+    }
+    return {
+        setLocale,
+        getLocale,
+        fullMonth,
+        fullYear,
+        fullMonthAndYear,
+        toParts,
+        custom,
+        part,
+        dayPeriod,
+        selectedDate,
+        dayOfWeek,
+        getMonths
+    };
+}
+
+/*
+ * Implementation ported from from from https://github.com/melt-ui/melt-ui/blob/develop/src/lib/internal/helpers/date/placeholders.ts
+ */
+// prettier-ignore
+const supportedLocales = [
+    'ach', 'af', 'am', 'an', 'ar', 'ast', 'az', 'be', 'bg', 'bn', 'br', 'bs',
+    'ca', 'cak', 'ckb', 'cs', 'cy', 'da', 'de', 'dsb', 'el', 'en', 'eo', 'es',
+    'et', 'eu', 'fa', 'ff', 'fi', 'fr', 'fy', 'ga', 'gd', 'gl', 'he', 'hr',
+    'hsb', 'hu', 'ia', 'id', 'it', 'ja', 'ka', 'kk', 'kn', 'ko', 'lb', 'lo',
+    'lt', 'lv', 'meh', 'ml', 'ms', 'nl', 'nn', 'no', 'oc', 'pl', 'pt', 'rm',
+    'ro', 'ru', 'sc', 'scn', 'sk', 'sl', 'sr', 'sv', 'szl', 'tg', 'th', 'tr',
+    'uk', 'zh-CN', 'zh-TW',
+];
+const placeholderFields = ['year', 'month', 'day'];
+const placeholders = {
+    ach: { year: 'mwaka', month: 'dwe', day: 'nino' },
+    af: { year: 'jjjj', month: 'mm', day: 'dd' },
+    am: { year: 'ዓዓዓዓ', month: 'ሚሜ', day: 'ቀቀ' },
+    an: { year: 'aaaa', month: 'mm', day: 'dd' },
+    ar: { year: 'سنة', month: 'شهر', day: 'يوم' },
+    ast: { year: 'aaaa', month: 'mm', day: 'dd' },
+    az: { year: 'iiii', month: 'aa', day: 'gg' },
+    be: { year: 'гггг', month: 'мм', day: 'дд' },
+    bg: { year: 'гггг', month: 'мм', day: 'дд' },
+    bn: { year: 'yyyy', month: 'মিমি', day: 'dd' },
+    br: { year: 'bbbb', month: 'mm', day: 'dd' },
+    bs: { year: 'gggg', month: 'mm', day: 'dd' },
+    ca: { year: 'aaaa', month: 'mm', day: 'dd' },
+    cak: { year: 'jjjj', month: 'ii', day: "q'q'" },
+    ckb: { year: 'ساڵ', month: 'مانگ', day: 'ڕۆژ' },
+    cs: { year: 'rrrr', month: 'mm', day: 'dd' },
+    cy: { year: 'bbbb', month: 'mm', day: 'dd' },
+    da: { year: 'åååå', month: 'mm', day: 'dd' },
+    de: { year: 'jjjj', month: 'mm', day: 'tt' },
+    dsb: { year: 'llll', month: 'mm', day: 'źź' },
+    el: { year: 'εεεε', month: 'μμ', day: 'ηη' },
+    en: { year: 'yyyy', month: 'mm', day: 'dd' },
+    eo: { year: 'jjjj', month: 'mm', day: 'tt' },
+    es: { year: 'aaaa', month: 'mm', day: 'dd' },
+    et: { year: 'aaaa', month: 'kk', day: 'pp' },
+    eu: { year: 'uuuu', month: 'hh', day: 'ee' },
+    fa: { year: 'سال', month: 'ماه', day: 'روز' },
+    ff: { year: 'hhhh', month: 'll', day: 'ññ' },
+    fi: { year: 'vvvv', month: 'kk', day: 'pp' },
+    fr: { year: 'aaaa', month: 'mm', day: 'jj' },
+    fy: { year: 'jjjj', month: 'mm', day: 'dd' },
+    ga: { year: 'bbbb', month: 'mm', day: 'll' },
+    gd: { year: 'bbbb', month: 'mm', day: 'll' },
+    gl: { year: 'aaaa', month: 'mm', day: 'dd' },
+    he: { year: 'שנה', month: 'חודש', day: 'יום' },
+    hr: { year: 'gggg', month: 'mm', day: 'dd' },
+    hsb: { year: 'llll', month: 'mm', day: 'dd' },
+    hu: { year: 'éééé', month: 'hh', day: 'nn' },
+    ia: { year: 'aaaa', month: 'mm', day: 'dd' },
+    id: { year: 'tttt', month: 'bb', day: 'hh' },
+    it: { year: 'aaaa', month: 'mm', day: 'gg' },
+    ja: { year: ' 年 ', month: '月', day: '日' },
+    ka: { year: 'წწწწ', month: 'თთ', day: 'რრ' },
+    kk: { year: 'жжжж', month: 'аа', day: 'кк' },
+    kn: { year: 'ವವವವ', month: 'ಮಿಮೀ', day: 'ದಿದಿ' },
+    ko: { year: '연도', month: '월', day: '일' },
+    lb: { year: 'jjjj', month: 'mm', day: 'dd' },
+    lo: { year: 'ປປປປ', month: 'ດດ', day: 'ວວ' },
+    lt: { year: 'mmmm', month: 'mm', day: 'dd' },
+    lv: { year: 'gggg', month: 'mm', day: 'dd' },
+    meh: { year: 'aaaa', month: 'mm', day: 'dd' },
+    ml: { year: 'വർഷം', month: 'മാസം', day: 'തീയതി' },
+    ms: { year: 'tttt', month: 'mm', day: 'hh' },
+    nl: { year: 'jjjj', month: 'mm', day: 'dd' },
+    nn: { year: 'åååå', month: 'mm', day: 'dd' },
+    no: { year: 'åååå', month: 'mm', day: 'dd' },
+    oc: { year: 'aaaa', month: 'mm', day: 'jj' },
+    pl: { year: 'rrrr', month: 'mm', day: 'dd' },
+    pt: { year: 'aaaa', month: 'mm', day: 'dd' },
+    rm: { year: 'oooo', month: 'mm', day: 'dd' },
+    ro: { year: 'aaaa', month: 'll', day: 'zz' },
+    ru: { year: 'гггг', month: 'мм', day: 'дд' },
+    sc: { year: 'aaaa', month: 'mm', day: 'dd' },
+    scn: { year: 'aaaa', month: 'mm', day: 'jj' },
+    sk: { year: 'rrrr', month: 'mm', day: 'dd' },
+    sl: { year: 'llll', month: 'mm', day: 'dd' },
+    sr: { year: 'гггг', month: 'мм', day: 'дд' },
+    sv: { year: 'åååå', month: 'mm', day: 'dd' },
+    szl: { year: 'rrrr', month: 'mm', day: 'dd' },
+    tg: { year: 'сссс', month: 'мм', day: 'рр' },
+    th: { year: 'ปปปป', month: 'ดด', day: 'วว' },
+    tr: { year: 'yyyy', month: 'aa', day: 'gg' },
+    uk: { year: 'рррр', month: 'мм', day: 'дд' },
+    'zh-CN': { year: '年', month: '月', day: '日' },
+    'zh-TW': { year: '年', month: '月', day: '日' }
+};
+function getPlaceholderObj(locale) {
+    if (!isSupportedLocale(locale)) {
+        const localeLanguage = getLocaleLanguage(locale);
+        if (!isSupportedLocale(localeLanguage)) {
+            return placeholders.en;
+        }
+        else {
+            return placeholders[localeLanguage];
+        }
+    }
+    else {
+        return placeholders[locale];
+    }
+}
+function getPlaceholder(field, value, locale) {
+    if (isPlaceholderField(field))
+        return getPlaceholderObj(locale)[field];
+    if (isDefaultField(field))
+        return value;
+    if (isTimeField(field))
+        return '––';
+    return '';
+}
+function isSupportedLocale(locale) {
+    return supportedLocales.includes(locale);
+}
+function isPlaceholderField(field) {
+    return placeholderFields.includes(field);
+}
+function isTimeField(field) {
+    return field === 'hour' || field === 'minute' || field === 'second';
+}
+function isDefaultField(field) {
+    return field === 'era' || field === 'dayPeriod';
+}
+function getLocaleLanguage(locale) {
+    if (Intl.Locale) {
+        return new Intl.Locale(locale).language;
+    }
+    return locale.split('-')[0];
+}
+
+/*
+ * Implementation ported from https://github.com/melt-ui/melt-ui/blob/develop/src/lib/internal/helpers/date/types.ts
+ */
+
+function handleCalendarInitialFocus(calendar) {
+    const selectedDay = calendar.querySelector('[data-selected]');
+    if (selectedDay)
+        return selectedDay.focus();
+    const today = calendar.querySelector('[data-today]');
+    if (today)
+        return today.focus();
+    const firstDay = calendar.querySelector('[data-rdx-calendar-day]');
+    if (firstDay)
+        return firstDay.focus();
+}
+
 var RdxPositionSide;
 (function (RdxPositionSide) {
     RdxPositionSide["Top"] = "top";
@@ -465,9 +970,46 @@ function getArrowPositionParams(sideAndAlign, arrowWidthAndHeight, triggerWidthA
     return posParams;
 }
 
+// https://ngxtension.netlify.app/utilities/signals/explicit-effect/
+/**
+ * This explicit effect function will take the dependencies and the function to run when the dependencies change.
+ *
+ * @example
+ * ```typescript
+ * import { watch } from 'radix-ng/primitives/core';
+ *
+ * const count = signal(0);
+ * const state = signal('idle');
+ *
+ * watch([count, state], ([count, state], cleanup) => {
+ *   console.log('count updated', count, state);
+ *
+ *   cleanup(() => {
+ *     console.log('cleanup');
+ *   });
+ * });
+ * ```
+ *
+ * @param deps - The dependencies that the effect will run on
+ * @param fn - The function to run when the dependencies change
+ * @param options - The options for the effect with the addition of defer (it allows the computation to run on first change, not immediately)
+ */
+function watch(deps, fn, options) {
+    let defer = options && options.defer;
+    return effect((onCleanup) => {
+        const depValues = deps.map((s) => s());
+        untracked(() => {
+            if (!defer) {
+                fn(depValues, onCleanup);
+            }
+            defer = false;
+        });
+    }, options);
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RDX_POSITIONING_DEFAULTS, RDX_POSITIONS, RdxAutoFocusDirective, RdxFocusInitialDirective, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, TAB, WINDOW, _IdGenerator, a, getAllPossibleConnectedPositions, getArrowPositionParams, getContentPosition, getSideAndAlignFromAllPossibleConnectedPositions, injectDocument, injectIsClient, injectNgControl, injectWindow, isInsideForm, isNullish, isNumber, j, k, n, p, provideValueAccessor };
+export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RDX_POSITIONING_DEFAULTS, RDX_POSITIONS, RdxAutoFocusDirective, RdxFocusInitialDirective, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, SPACE_CODE, TAB, WINDOW, _IdGenerator, a, areAllDaysBetweenValid, createFormatter, createMonth, createMonths, getAllPossibleConnectedPositions, getArrowPositionParams, getContentPosition, getDaysBetween, getDaysInMonth, getDefaultDate, getLastFirstDayOfWeek, getNextLastDayOfWeek, getPlaceholder, getSideAndAlignFromAllPossibleConnectedPositions, handleCalendarInitialFocus, hasTime, injectDocument, injectIsClient, injectNgControl, injectWindow, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isInsideForm, isNullish, isNumber, isZonedDateTime, j, k, n, p, provideValueAccessor, toDate, watch };
 //# sourceMappingURL=radix-ng-primitives-core.mjs.map