@radix-ng/primitives 0.12.1 → 0.13.0

package/esm2022/progress/src/progress-root.directive.mjs

@@ -0,0 +1,127 @@
+import { Directive, inject, InjectionToken, Input, numberAttribute } from '@angular/core';
+import * as i0 from "@angular/core";
+let idIterator = 0;
+const MIN_PERCENT = 0;
+const DEFAULT_MAX = 100;
+const PROGRESS_NAME = 'Radix Progress';
+const RdxProgressToken = new InjectionToken('RdxProgressDirective');
+/**
+ * Injects the current instance of RdxProgressRootDirective.
+ * @returns The instance of RdxProgressRootDirective.
+ */
+export function injectProgress() {
+    return inject(RdxProgressToken);
+}
+/**
+ * Directive to manage progress bar state and attributes.
+ *
+ * This directive provides a way to create a progress bar with customizable value and max attributes.
+ * It handles aria attributes for accessibility and provides different states like 'indeterminate', 'complete', and 'loading'.
+ */
+export class RdxProgressRootDirective {
+    constructor() {
+        /**
+         * The unique ID for the progress bar.
+         * @default 'rdx-progress-bar-{idIterator}'
+         */
+        this.id = `rdx-progress-bar-${idIterator++}`;
+        /**
+         * The current value of the progress bar.
+         * @default 0
+         */
+        this.value = MIN_PERCENT;
+        /**
+         * The maximum value of the progress bar.
+         * @default 100
+         */
+        this.max = DEFAULT_MAX;
+        /**
+         * Function to generate the value label.
+         */
+        this.valueLabel = (value, max) => this.defaultGetValueLabel(value, max);
+    }
+    /**
+     * Lifecycle hook that is called when any data-bound property of a directive changes.
+     * @param changes - The changed properties.
+     * @ignore
+     */
+    ngOnChanges(changes) {
+        if (changes['max'] && !this.isValidMaxNumber(this.max)) {
+            console.error(this.getInvalidMaxError(`${this.max}`, PROGRESS_NAME));
+        }
+        if (changes['value'] && this.value !== null && !this.isValidValueNumber(this.value, this.max)) {
+            console.error(this.getInvalidValueError(`${this.value}`, PROGRESS_NAME));
+        }
+    }
+    /**
+     * Get the state of the progress bar.
+     * @returns 'indeterminate' | 'loading' | 'complete'
+     * @ignore
+     */
+    get state() {
+        return this.getProgressState(this.value, this.max);
+    }
+    getProgressState(value, maxValue) {
+        return value == null ? 'indeterminate' : value === maxValue ? 'complete' : 'loading';
+    }
+    defaultGetValueLabel(value, max) {
+        return `${Math.round((value / max) * 100)}%`;
+    }
+    isValidMaxNumber(max) {
+        return this.isNumber(max) && !isNaN(max) && max > 0;
+    }
+    isNumber(value) {
+        return typeof value === 'number';
+    }
+    isValidValueNumber(value, max) {
+        return this.isNumber(value) && !isNaN(value) && value <= max && value >= 0;
+    }
+    getInvalidMaxError(propValue, componentName) {
+        return `Invalid prop \`max\` of value \`${propValue}\` supplied to \`${componentName}\`. Only numbers greater than 0 are valid max values. Defaulting to \`${DEFAULT_MAX}\`.`;
+    }
+    getInvalidValueError(propValue, componentName) {
+        return `Invalid prop \`value\` of value \`${propValue}\` supplied to \`${componentName}\`. The \`value\` prop must be:
+    - a positive number
+    - less than the value passed to \`max\` (or ${DEFAULT_MAX} if no \`max\` prop is set)
+    - \`null\` or \`undefined\` if the progress is indeterminate.
+
+    Defaulting to \`null\`.`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxProgressRootDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.1", type: RdxProgressRootDirective, isStandalone: true, selector: "[rdxProgressRoot]", inputs: { id: "id", value: ["rdxValue", "value", numberAttribute], max: ["rdxMax", "max", numberAttribute], valueLabel: ["rdxValueLabel", "valueLabel"] }, host: { attributes: { "role": "progressbar", "tabindex": "-1" }, properties: { "id": "id", "attr.aria-valuemax": "max", "attr.aria-valuemin": "0", "attr.aria-valuenow": "value", "attr.aria-valuetext": "valueLabel(value, max)", "attr.data-state": "state", "attr.data-value": "value", "attr.data-max": "max" } }, providers: [{ provide: RdxProgressToken, useExisting: RdxProgressRootDirective }], exportAs: ["rdxProgressRoot"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxProgressRootDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxProgressRoot]',
+                    exportAs: 'rdxProgressRoot',
+                    standalone: true,
+                    providers: [{ provide: RdxProgressToken, useExisting: RdxProgressRootDirective }],
+                    host: {
+                        role: 'progressbar',
+                        '[id]': 'id',
+                        '[attr.aria-valuemax]': 'max',
+                        '[attr.aria-valuemin]': '0',
+                        '[attr.aria-valuenow]': 'value',
+                        '[attr.aria-valuetext]': 'valueLabel(value, max)',
+                        '[attr.data-state]': 'state',
+                        '[attr.data-value]': 'value',
+                        '[attr.data-max]': 'max',
+                        // set tab index to -1 so screen readers will read the aria-label
+                        // Note: there is a known issue with JAWS that does not read progressbar aria labels on FireFox
+                        tabindex: '-1'
+                    }
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], value: [{
+                type: Input,
+                args: [{ alias: 'rdxValue', transform: numberAttribute }]
+            }], max: [{
+                type: Input,
+                args: [{ alias: 'rdxMax', transform: numberAttribute }]
+            }], valueLabel: [{
+                type: Input,
+                args: ['rdxValueLabel']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progress-root.directive.js","sourceRoot":"","sources":["../../../../../packages/primitives/progress/src/progress-root.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, InjectionToken, Input, numberAttribute, OnChanges, SimpleChanges } from '@angular/core';\n\nlet idIterator = 0;\n\nconst MIN_PERCENT = 0;\nconst DEFAULT_MAX = 100;\nconst PROGRESS_NAME = 'Radix Progress';\n\nconst RdxProgressToken = new InjectionToken<RdxProgressRootDirective>('RdxProgressDirective');\n\n/**\n * Injects the current instance of RdxProgressRootDirective.\n * @returns The instance of RdxProgressRootDirective.\n */\nexport function injectProgress(): RdxProgressRootDirective {\n    return inject(RdxProgressToken);\n}\n\nexport type ProgressState = 'indeterminate' | 'complete' | 'loading';\n\nexport interface ProgressProps {\n    value?: number | null | undefined;\n    max?: number;\n    getValueLabel?: string;\n}\n\n/**\n * Directive to manage progress bar state and attributes.\n *\n * This directive provides a way to create a progress bar with customizable value and max attributes.\n * It handles aria attributes for accessibility and provides different states like 'indeterminate', 'complete', and 'loading'.\n */\n@Directive({\n    selector: '[rdxProgressRoot]',\n    exportAs: 'rdxProgressRoot',\n    standalone: true,\n    providers: [{ provide: RdxProgressToken, useExisting: RdxProgressRootDirective }],\n    host: {\n        role: 'progressbar',\n        '[id]': 'id',\n        '[attr.aria-valuemax]': 'max',\n        '[attr.aria-valuemin]': '0',\n        '[attr.aria-valuenow]': 'value',\n        '[attr.aria-valuetext]': 'valueLabel(value, max)',\n        '[attr.data-state]': 'state',\n        '[attr.data-value]': 'value',\n        '[attr.data-max]': 'max',\n        // set tab index to -1 so screen readers will read the aria-label\n        // Note: there is a known issue with JAWS that does not read progressbar aria labels on FireFox\n        tabindex: '-1'\n    }\n})\nexport class RdxProgressRootDirective implements ProgressProps, OnChanges {\n    /**\n     * The unique ID for the progress bar.\n     * @default 'rdx-progress-bar-{idIterator}'\n     */\n    @Input() id = `rdx-progress-bar-${idIterator++}`;\n\n    /**\n     * The current value of the progress bar.\n     * @default 0\n     */\n    @Input({ alias: 'rdxValue', transform: numberAttribute }) value = MIN_PERCENT;\n\n    /**\n     * The maximum value of the progress bar.\n     * @default 100\n     */\n    @Input({ alias: 'rdxMax', transform: numberAttribute }) max = DEFAULT_MAX;\n\n    /**\n     * Function to generate the value label.\n     */\n    @Input('rdxValueLabel') valueLabel: (value: number, max: number) => string = (value, max) =>\n        this.defaultGetValueLabel(value, max);\n\n    /**\n     * Lifecycle hook that is called when any data-bound property of a directive changes.\n     * @param changes - The changed properties.\n     * @ignore\n     */\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['max'] && !this.isValidMaxNumber(this.max)) {\n            console.error(this.getInvalidMaxError(`${this.max}`, PROGRESS_NAME));\n        }\n\n        if (changes['value'] && this.value !== null && !this.isValidValueNumber(this.value, this.max)) {\n            console.error(this.getInvalidValueError(`${this.value}`, PROGRESS_NAME));\n        }\n    }\n\n    /**\n     * Get the state of the progress bar.\n     * @returns 'indeterminate' | 'loading' | 'complete'\n     * @ignore\n     */\n    get state(): ProgressState {\n        return this.getProgressState(this.value, this.max);\n    }\n\n    private getProgressState(value: number | undefined | null, maxValue: number): ProgressState {\n        return value == null ? 'indeterminate' : value === maxValue ? 'complete' : 'loading';\n    }\n\n    private defaultGetValueLabel(value: number, max: number) {\n        return `${Math.round((value / max) * 100)}%`;\n    }\n\n    private isValidMaxNumber(max: unknown): max is number {\n        return this.isNumber(max) && !isNaN(max) && max > 0;\n    }\n\n    private isNumber(value: unknown): value is number {\n        return typeof value === 'number';\n    }\n\n    private isValidValueNumber(value: unknown, max: number): value is number {\n        return this.isNumber(value) && !isNaN(value) && value <= max && value >= 0;\n    }\n\n    private getInvalidMaxError(propValue: string, componentName: string): string {\n        return `Invalid prop \\`max\\` of value \\`${propValue}\\` supplied to \\`${componentName}\\`. Only numbers greater than 0 are valid max values. Defaulting to \\`${DEFAULT_MAX}\\`.`;\n    }\n\n    private getInvalidValueError(propValue: string, componentName: string): string {\n        return `Invalid prop \\`value\\` of value \\`${propValue}\\` supplied to \\`${componentName}\\`. The \\`value\\` prop must be:\n    - a positive number\n    - less than the value passed to \\`max\\` (or ${DEFAULT_MAX} if no \\`max\\` prop is set)\n    - \\`null\\` or \\`undefined\\` if the progress is indeterminate.\n\n    Defaulting to \\`null\\`.`;\n    }\n}\n"]}

package/esm2022/radio/index.mjs

@@ -0,0 +1,4 @@
+export * from './src/radio-root.directive';
+export * from './src/radio-indicator.directive';
+export * from './src/radio-item.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL3JhZGlvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNEJBQTRCLENBQUM7QUFFM0MsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zcmMvcmFkaW8tcm9vdC5kaXJlY3RpdmUnO1xuXG5leHBvcnQgKiBmcm9tICcuL3NyYy9yYWRpby1pbmRpY2F0b3IuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3JhZGlvLWl0ZW0uZGlyZWN0aXZlJztcbiJdfQ==

package/esm2022/radio/radix-ng-primitives-radio.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaXgtbmctcHJpbWl0aXZlcy1yYWRpby5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL3ByaW1pdGl2ZXMvcmFkaW8vcmFkaXgtbmctcHJpbWl0aXZlcy1yYWRpby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/radio/src/radio-indicator.directive.mjs

@@ -0,0 +1,25 @@
+import { Directive, inject } from '@angular/core';
+import { RdxRadioItemDirective } from './radio-item.directive';
+import { RDX_RADIO_GROUP } from './radio-tokens';
+import * as i0 from "@angular/core";
+export class RdxRadioIndicatorDirective {
+    constructor() {
+        this.radioGroup = inject(RDX_RADIO_GROUP);
+        this.radioItem = inject(RdxRadioItemDirective);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxRadioIndicatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.1", type: RdxRadioIndicatorDirective, isStandalone: true, selector: "[rdxRadioIndicator]", host: { properties: { "attr.data-state": "radioItem.checked ? \"checked\" : \"unchecked\"", "attr.data-disabled": "radioItem.disabled ? \"\" : null" } }, exportAs: ["rdxRadioIndicator"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxRadioIndicatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxRadioIndicator]',
+                    exportAs: 'rdxRadioIndicator',
+                    standalone: true,
+                    host: {
+                        '[attr.data-state]': 'radioItem.checked ? "checked" : "unchecked"',
+                        '[attr.data-disabled]': 'radioItem.disabled ? "" : null'
+                    }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaW8taW5kaWNhdG9yLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3ByaW1pdGl2ZXMvcmFkaW8vc3JjL3JhZGlvLWluZGljYXRvci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbEQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDL0QsT0FBTyxFQUFFLGVBQWUsRUFBdUIsTUFBTSxnQkFBZ0IsQ0FBQzs7QUFXdEUsTUFBTSxPQUFPLDBCQUEwQjtJQVR2QztRQVV1QixlQUFVLEdBQXdCLE1BQU0sQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUMxRCxjQUFTLEdBQTBCLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO0tBQ3ZGOzhHQUhZLDBCQUEwQjtrR0FBMUIsMEJBQTBCOzsyRkFBMUIsMEJBQTBCO2tCQVR0QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxxQkFBcUI7b0JBQy9CLFFBQVEsRUFBRSxtQkFBbUI7b0JBQzdCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixJQUFJLEVBQUU7d0JBQ0YsbUJBQW1CLEVBQUUsNkNBQTZDO3dCQUNsRSxzQkFBc0IsRUFBRSxnQ0FBZ0M7cUJBQzNEO2lCQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJkeFJhZGlvSXRlbURpcmVjdGl2ZSB9IGZyb20gJy4vcmFkaW8taXRlbS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgUkRYX1JBRElPX0dST1VQLCBSYWRpb0dyb3VwRGlyZWN0aXZlIH0gZnJvbSAnLi9yYWRpby10b2tlbnMnO1xuXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJ1tyZHhSYWRpb0luZGljYXRvcl0nLFxuICAgIGV4cG9ydEFzOiAncmR4UmFkaW9JbmRpY2F0b3InLFxuICAgIHN0YW5kYWxvbmU6IHRydWUsXG4gICAgaG9zdDoge1xuICAgICAgICAnW2F0dHIuZGF0YS1zdGF0ZV0nOiAncmFkaW9JdGVtLmNoZWNrZWQgPyBcImNoZWNrZWRcIiA6IFwidW5jaGVja2VkXCInLFxuICAgICAgICAnW2F0dHIuZGF0YS1kaXNhYmxlZF0nOiAncmFkaW9JdGVtLmRpc2FibGVkID8gXCJcIiA6IG51bGwnXG4gICAgfVxufSlcbmV4cG9ydCBjbGFzcyBSZHhSYWRpb0luZGljYXRvckRpcmVjdGl2ZSB7XG4gICAgcHJvdGVjdGVkIHJlYWRvbmx5IHJhZGlvR3JvdXA6IFJhZGlvR3JvdXBEaXJlY3RpdmUgPSBpbmplY3QoUkRYX1JBRElPX0dST1VQKTtcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgcmFkaW9JdGVtOiBSZHhSYWRpb0l0ZW1EaXJlY3RpdmUgPSBpbmplY3QoUmR4UmFkaW9JdGVtRGlyZWN0aXZlKTtcbn1cbiJdfQ==

package/esm2022/radio/src/radio-item.directive.mjs

@@ -0,0 +1,70 @@
+import { booleanAttribute, Directive, ElementRef, inject, InjectionToken, Input } from '@angular/core';
+import { RDX_RADIO_GROUP } from './radio-tokens';
+import * as i0 from "@angular/core";
+export const RdxRadioItemToken = new InjectionToken('RadioItemToken');
+export function injectRadioItem() {
+    return inject(RdxRadioItemToken);
+}
+// Increasing integer for generating unique ids for radio components.
+let nextUniqueId = 0;
+export class RdxRadioItemDirective {
+    constructor() {
+        this.radioGroup = inject(RDX_RADIO_GROUP);
+        this.element = inject(ElementRef);
+        this.id = `rdx-radio-${++nextUniqueId}`;
+        this.disabled = false;
+    }
+    get tabIndex() {
+        return this.disabled ? -1 : this.radioGroup.value === this.value ? 0 : -1;
+    }
+    get checked() {
+        return this.radioGroup.value === this.value;
+    }
+    ngOnInit() {
+        if (this.radioGroup.defaultValue === this.value) {
+            this.radioGroup.select(this.value);
+        }
+    }
+    focus() {
+        this.element.nativeElement.focus();
+    }
+    _onClick() {
+        if (!this.disabled) {
+            this.radioGroup.select(this.value);
+        }
+    }
+    _onBlur() {
+        this.radioGroup.onTouched?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxRadioItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.1", type: RdxRadioItemDirective, isStandalone: true, selector: "[rdxRadioItem]", inputs: { id: "id", value: "value", disabled: ["disabled", "disabled", booleanAttribute] }, host: { attributes: { "type": "button", "role": "radio" }, listeners: { "click": "_onClick()", "blur": "_onBlur()" }, properties: { "attr.id": "id", "attr.aria-checked": "checked", "attr.data-disabled": "disabled ? \"\" : null", "attr.data-state": "checked ? \"checked\" : \"unchecked\"", "attr.tabindex": "tabIndex" } }, providers: [{ provide: RdxRadioItemToken, useExisting: RdxRadioItemDirective }], exportAs: ["rdxRadioItem"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxRadioItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxRadioItem]',
+                    exportAs: 'rdxRadioItem',
+                    standalone: true,
+                    providers: [{ provide: RdxRadioItemToken, useExisting: RdxRadioItemDirective }],
+                    host: {
+                        type: 'button',
+                        role: 'radio',
+                        '[attr.id]': 'id',
+                        '[attr.aria-checked]': 'checked',
+                        '[attr.data-disabled]': 'disabled ? "" : null',
+                        '[attr.data-state]': 'checked ? "checked" : "unchecked"',
+                        '[attr.tabindex]': 'tabIndex',
+                        '(click)': '_onClick()',
+                        '(blur)': '_onBlur()'
+                    }
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], value: [{
+                type: Input,
+                args: [{ required: true }]
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/radio/src/radio-root.directive.mjs

@@ -0,0 +1,194 @@
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { DOWN_ARROW, ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE, TAB, UP_ARROW } from '@angular/cdk/keycodes';
+import { booleanAttribute, ContentChildren, Directive, EventEmitter, Input, Output, QueryList } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject, takeUntil } from 'rxjs';
+import { RdxRadioItemDirective } from './radio-item.directive';
+import { RDX_RADIO_GROUP } from './radio-tokens';
+import * as i0 from "@angular/core";
+export class RdxRadioGroupDirective {
+    constructor() {
+        this.destroy$ = new Subject();
+        this.disabled = false;
+        /**
+         * The orientation of the radio group only vertical.
+         * Horizontal radio buttons can sometimes be challenging to scan and localize.
+         * The horizontal arrangement of radio buttons may also lead to difficulties in determining which
+         * label corresponds to which button: whether the label is above or below the button.
+         * @default 'vertical'
+         */
+        this._orientation = 'vertical';
+        /**
+         * Event handler called when the value changes.
+         */
+        this.onValueChange = new EventEmitter();
+        /**
+         * The callback function to call when the value of the radio group changes.
+         */
+        this.onChange = () => {
+            /* Empty */
+        };
+        /**
+         * The callback function to call when the radio group is touched.
+         */
+        this.onTouched = () => {
+            /* Empty */
+        };
+    }
+    ngAfterContentInit() {
+        this.focusKeyManager = new FocusKeyManager(this.radioItems).withWrap().withVerticalOrientation();
+        this.radioItems.changes.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.updateActiveItem();
+        });
+        this.updateActiveItem(false);
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    /**
+     * Select a radio item.
+     * @param value The value of the radio item to select.
+     */
+    select(value) {
+        this.value = value;
+        this.onValueChange.emit(value);
+        this.onChange?.(value);
+        this.updateActiveItem();
+        this.onTouched();
+    }
+    /**
+     * Update the value of the radio group.
+     * @param value The new value of the radio group.
+     * @internal
+     */
+    writeValue(value) {
+        this.value = value;
+        if (this.radioItems) {
+            this.updateActiveItem(false);
+        }
+    }
+    /**
+     * Register a callback function to call when the value of the radio group changes.
+     * @param fn The callback function to call when the value of the radio group changes.
+     * @internal
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * Set the disabled state of the radio group.
+     * @param isDisabled Whether the radio group is disabled.
+     * @internal
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     * When focus leaves the radio group.
+     */
+    _onFocusin(event) {
+        const target = event.target;
+        const radioItem = this.radioItems.find((item) => item.element.nativeElement === target);
+        if (radioItem) {
+            this.focusKeyManager.setActiveItem(radioItem);
+        }
+    }
+    _onKeydown(event) {
+        if (this.disabled)
+            return;
+        switch (event.keyCode) {
+            case ENTER:
+            case SPACE:
+                event.preventDefault();
+                this.selectFocusedItem();
+                break;
+            case DOWN_ARROW:
+            case RIGHT_ARROW:
+                event.preventDefault();
+                this.focusKeyManager.setNextItemActive();
+                this.selectFocusedItem();
+                break;
+            case UP_ARROW:
+            case LEFT_ARROW:
+                event.preventDefault();
+                this.focusKeyManager.setPreviousItemActive();
+                this.selectFocusedItem();
+                break;
+            case TAB:
+                this.tabNavigation(event);
+                break;
+            default:
+                this.focusKeyManager.onKeydown(event);
+        }
+    }
+    selectFocusedItem() {
+        const focusedItem = this.focusKeyManager.activeItem;
+        if (focusedItem) {
+            this.select(focusedItem.value);
+        }
+    }
+    updateActiveItem(setFocus = true) {
+        const activeItem = this.radioItems.find((item) => item.value === this.value);
+        if (activeItem) {
+            this.focusKeyManager.setActiveItem(activeItem);
+        }
+        else if (this.radioItems.length > 0 && setFocus) {
+            this.focusKeyManager.setFirstItemActive();
+        }
+    }
+    tabNavigation(event) {
+        event.preventDefault();
+        const checkedItem = this.radioItems.find((item) => item.checked);
+        if (checkedItem) {
+            checkedItem.focus();
+        }
+        else if (this.radioItems.first) {
+            this.radioItems.first.focus();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxRadioGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.1", type: RdxRadioGroupDirective, isStandalone: true, selector: "[rdxRadioRoot]", inputs: { value: "value", disabled: ["disabled", "disabled", booleanAttribute], dir: "dir", defaultValue: "defaultValue" }, outputs: { onValueChange: "onValueChange" }, host: { attributes: { "role": "radiogroup" }, listeners: { "keydown": "_onKeydown($event)", "focusin": "_onFocusin($event)" }, properties: { "attr.aria-orientation": "_orientation", "attr.data-disabled": "disabled ? \"\" : null", "attr.tabindex": "-1", "attr.dir": "dir" } }, providers: [
+            { provide: RDX_RADIO_GROUP, useExisting: RdxRadioGroupDirective },
+            { provide: NG_VALUE_ACCESSOR, useExisting: RdxRadioGroupDirective, multi: true }
+        ], queries: [{ propertyName: "radioItems", predicate: RdxRadioItemDirective, descendants: true }], exportAs: ["rdxRadioRoot"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxRadioGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxRadioRoot]',
+                    exportAs: 'rdxRadioRoot',
+                    standalone: true,
+                    providers: [
+                        { provide: RDX_RADIO_GROUP, useExisting: RdxRadioGroupDirective },
+                        { provide: NG_VALUE_ACCESSOR, useExisting: RdxRadioGroupDirective, multi: true }
+                    ],
+                    host: {
+                        role: 'radiogroup',
+                        '[attr.aria-orientation]': '_orientation',
+                        '[attr.data-disabled]': 'disabled ? "" : null',
+                        '[attr.tabindex]': '-1',
+                        '[attr.dir]': 'dir',
+                        '(keydown)': '_onKeydown($event)',
+                        '(focusin)': '_onFocusin($event)'
+                    }
+                }]
+        }], propDecorators: { radioItems: [{
+                type: ContentChildren,
+                args: [RdxRadioItemDirective, { descendants: true }]
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], dir: [{
+                type: Input
+            }], defaultValue: [{
+                type: Input
+            }], onValueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"radio-root.directive.js","sourceRoot":"","sources":["../../../../../packages/primitives/radio/src/radio-root.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusKeyManager } from '@angular/cdk/a11y';\nimport { DOWN_ARROW, ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE, TAB, UP_ARROW } from '@angular/cdk/keycodes';\nimport {\n    AfterContentInit,\n    booleanAttribute,\n    ContentChildren,\n    Directive,\n    EventEmitter,\n    Input,\n    OnDestroy,\n    Output,\n    QueryList\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { Subject, takeUntil } from 'rxjs';\nimport { RdxRadioItemDirective } from './radio-item.directive';\nimport { RadioGroupDirective, RadioGroupProps, RDX_RADIO_GROUP } from './radio-tokens';\n\n@Directive({\n    selector: '[rdxRadioRoot]',\n    exportAs: 'rdxRadioRoot',\n    standalone: true,\n    providers: [\n        { provide: RDX_RADIO_GROUP, useExisting: RdxRadioGroupDirective },\n        { provide: NG_VALUE_ACCESSOR, useExisting: RdxRadioGroupDirective, multi: true }\n    ],\n    host: {\n        role: 'radiogroup',\n        '[attr.aria-orientation]': '_orientation',\n        '[attr.data-disabled]': 'disabled ? \"\" : null',\n        '[attr.tabindex]': '-1',\n        '[attr.dir]': 'dir',\n        '(keydown)': '_onKeydown($event)',\n        '(focusin)': '_onFocusin($event)'\n    }\n})\nexport class RdxRadioGroupDirective\n    implements RadioGroupProps, RadioGroupDirective, ControlValueAccessor, AfterContentInit, OnDestroy\n{\n    @ContentChildren(RdxRadioItemDirective, { descendants: true }) radioItems!: QueryList<RdxRadioItemDirective>;\n    private focusKeyManager!: FocusKeyManager<RdxRadioItemDirective>;\n    private destroy$ = new Subject<void>();\n\n    name?: string | undefined;\n    @Input() value?: string;\n\n    @Input({ transform: booleanAttribute }) disabled = false;\n\n    @Input() dir?: string;\n\n    @Input() defaultValue?: string;\n\n    /**\n     * The orientation of the radio group only vertical.\n     * Horizontal radio buttons can sometimes be challenging to scan and localize.\n     * The horizontal arrangement of radio buttons may also lead to difficulties in determining which\n     * label corresponds to which button: whether the label is above or below the button.\n     * @default 'vertical'\n     */\n    readonly _orientation = 'vertical';\n\n    /**\n     * Event handler called when the value changes.\n     */\n    @Output() readonly onValueChange = new EventEmitter<string>();\n\n    /**\n     * The callback function to call when the value of the radio group changes.\n     */\n    private onChange: (value: string) => void = () => {\n        /* Empty */\n    };\n\n    /**\n     * The callback function to call when the radio group is touched.\n     */\n    onTouched: () => void = () => {\n        /* Empty */\n    };\n\n    ngAfterContentInit() {\n        this.focusKeyManager = new FocusKeyManager(this.radioItems).withWrap().withVerticalOrientation();\n\n        this.radioItems.changes.pipe(takeUntil(this.destroy$)).subscribe(() => {\n            this.updateActiveItem();\n        });\n\n        this.updateActiveItem(false);\n    }\n\n    ngOnDestroy() {\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    /**\n     * Select a radio item.\n     * @param value The value of the radio item to select.\n     */\n    select(value: string): void {\n        this.value = value;\n        this.onValueChange.emit(value);\n        this.onChange?.(value);\n        this.updateActiveItem();\n        this.onTouched();\n    }\n\n    /**\n     * Update the value of the radio group.\n     * @param value The new value of the radio group.\n     * @internal\n     */\n    writeValue(value: string): void {\n        this.value = value;\n        if (this.radioItems) {\n            this.updateActiveItem(false);\n        }\n    }\n\n    /**\n     * Register a callback function to call when the value of the radio group changes.\n     * @param fn The callback function to call when the value of the radio group changes.\n     * @internal\n     */\n    registerOnChange(fn: (value: string) => void): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: () => void): void {\n        this.onTouched = fn;\n    }\n\n    /**\n     * Set the disabled state of the radio group.\n     * @param isDisabled Whether the radio group is disabled.\n     * @internal\n     */\n    setDisabledState(isDisabled: boolean): void {\n        this.disabled = isDisabled;\n    }\n\n    /**\n     * When focus leaves the radio group.\n     */\n    _onFocusin(event: FocusEvent): void {\n        const target = event.target as HTMLElement;\n        const radioItem = this.radioItems.find((item) => item.element.nativeElement === target);\n        if (radioItem) {\n            this.focusKeyManager.setActiveItem(radioItem);\n        }\n    }\n\n    _onKeydown(event: KeyboardEvent): void {\n        if (this.disabled) return;\n\n        switch (event.keyCode) {\n            case ENTER:\n            case SPACE:\n                event.preventDefault();\n                this.selectFocusedItem();\n                break;\n            case DOWN_ARROW:\n            case RIGHT_ARROW:\n                event.preventDefault();\n                this.focusKeyManager.setNextItemActive();\n                this.selectFocusedItem();\n                break;\n            case UP_ARROW:\n            case LEFT_ARROW:\n                event.preventDefault();\n                this.focusKeyManager.setPreviousItemActive();\n                this.selectFocusedItem();\n                break;\n            case TAB:\n                this.tabNavigation(event);\n                break;\n            default:\n                this.focusKeyManager.onKeydown(event);\n        }\n    }\n\n    private selectFocusedItem(): void {\n        const focusedItem = this.focusKeyManager.activeItem;\n        if (focusedItem) {\n            this.select(focusedItem.value);\n        }\n    }\n\n    private updateActiveItem(setFocus = true): void {\n        const activeItem = this.radioItems.find((item) => item.value === this.value);\n        if (activeItem) {\n            this.focusKeyManager.setActiveItem(activeItem);\n        } else if (this.radioItems.length > 0 && setFocus) {\n            this.focusKeyManager.setFirstItemActive();\n        }\n    }\n\n    private tabNavigation(event: KeyboardEvent): void {\n        event.preventDefault();\n        const checkedItem = this.radioItems.find((item) => item.checked);\n        if (checkedItem) {\n            checkedItem.focus();\n        } else if (this.radioItems.first) {\n            this.radioItems.first.focus();\n        }\n    }\n}\n"]}

package/esm2022/radio/src/radio-tokens.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const RDX_RADIO_GROUP = new InjectionToken('RdxRadioGroup');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaW8tdG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcHJpbWl0aXZlcy9yYWRpby9zcmMvcmFkaW8tdG9rZW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFlL0MsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLElBQUksY0FBYyxDQUFzQixlQUFlLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmFkaW9Hcm91cFByb3BzIHtcbiAgICBuYW1lPzogc3RyaW5nO1xuICAgIGRpc2FibGVkPzogYm9vbGVhbjtcbiAgICBkZWZhdWx0VmFsdWU/OiBzdHJpbmc7XG4gICAgdmFsdWU/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmFkaW9Hcm91cERpcmVjdGl2ZSBleHRlbmRzIFJhZGlvR3JvdXBQcm9wcyB7XG4gICAgc2VsZWN0KHZhbHVlOiBzdHJpbmcpOiB2b2lkO1xuXG4gICAgb25Ub3VjaGVkKCk6IHZvaWQ7XG59XG5cbmV4cG9ydCBjb25zdCBSRFhfUkFESU9fR1JPVVAgPSBuZXcgSW5qZWN0aW9uVG9rZW48UmFkaW9Hcm91cERpcmVjdGl2ZT4oJ1JkeFJhZGlvR3JvdXAnKTtcbiJdfQ==

package/esm2022/radix-ng-primitives.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaXgtbmctcHJpbWl0aXZlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BhY2thZ2VzL3ByaW1pdGl2ZXMvcmFkaXgtbmctcHJpbWl0aXZlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/separator/index.mjs

@@ -0,0 +1,2 @@
+export * from './src/separator.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL3NlcGFyYXRvci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zcmMvc2VwYXJhdG9yLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2022/separator/radix-ng-primitives-separator.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaXgtbmctcHJpbWl0aXZlcy1zZXBhcmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL3NlcGFyYXRvci9yYWRpeC1uZy1wcmltaXRpdmVzLXNlcGFyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/separator/src/separator.directive.mjs

@@ -0,0 +1,32 @@
+import { booleanAttribute, Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+const DEFAULT_ORIENTATION = 'horizontal';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const ORIENTATIONS = ['horizontal', 'vertical'];
+export class RdxSeparatorRootDirective {
+    constructor() {
+        this.orientation = DEFAULT_ORIENTATION;
+        this.decorative = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxSeparatorRootDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.1", type: RdxSeparatorRootDirective, isStandalone: true, selector: "div[rdxSeparatorRoot]", inputs: { orientation: "orientation", decorative: ["decorative", "decorative", booleanAttribute] }, host: { properties: { "attr.role": "decorative ? \"none\" : \"separator\"", "attr.aria-orientation": "!decorative && orientation === \"vertical\" ? \"vertical\" : null", "attr.data-orientation": "orientation" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxSeparatorRootDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'div[rdxSeparatorRoot]',
+                    standalone: true,
+                    host: {
+                        '[attr.role]': 'decorative ? "none" : "separator"',
+                        // `aria-orientation` defaults to `horizontal` so we only need it if `orientation` is vertical
+                        '[attr.aria-orientation]': '!decorative && orientation === "vertical" ? "vertical" : null',
+                        '[attr.data-orientation]': 'orientation'
+                    }
+                }]
+        }], propDecorators: { orientation: [{
+                type: Input
+            }], decorative: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/switch/index.mjs

@@ -0,0 +1,30 @@
+import { NgModule } from '@angular/core';
+import { RdxSwitchInputDirective } from './src/switch-input.directive';
+import { RdxSwitchRootDirective } from './src/switch-root.directive';
+import { RdxSwitchThumbDirective } from './src/switch-thumb.directive';
+import * as i0 from "@angular/core";
+export * from './src/switch-input.directive';
+export * from './src/switch-root.directive';
+export * from './src/switch-thumb.directive';
+const switchImports = [
+    RdxSwitchRootDirective,
+    RdxSwitchInputDirective,
+    RdxSwitchThumbDirective
+];
+export class RdxSwitchModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxSwitchModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.1", ngImport: i0, type: RdxSwitchModule, imports: [RdxSwitchRootDirective,
+            RdxSwitchInputDirective,
+            RdxSwitchThumbDirective], exports: [RdxSwitchRootDirective,
+            RdxSwitchInputDirective,
+            RdxSwitchThumbDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxSwitchModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: RdxSwitchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...switchImports],
+                    exports: [...switchImports]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL3N3aXRjaC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3JFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDOztBQUV2RSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw4QkFBOEIsQ0FBQztBQUk3QyxNQUFNLGFBQWEsR0FBRztJQUNsQixzQkFBc0I7SUFDdEIsdUJBQXVCO0lBQ3ZCLHVCQUF1QjtDQUMxQixDQUFDO0FBTUYsTUFBTSxPQUFPLGVBQWU7OEdBQWYsZUFBZTsrR0FBZixlQUFlLFlBVHhCLHNCQUFzQjtZQUN0Qix1QkFBdUI7WUFDdkIsdUJBQXVCLGFBRnZCLHNCQUFzQjtZQUN0Qix1QkFBdUI7WUFDdkIsdUJBQXVCOytHQU9kLGVBQWU7OzJGQUFmLGVBQWU7a0JBSjNCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMsR0FBRyxhQUFhLENBQUM7b0JBQzNCLE9BQU8sRUFBRSxDQUFDLEdBQUcsYUFBYSxDQUFDO2lCQUM5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZHhTd2l0Y2hJbnB1dERpcmVjdGl2ZSB9IGZyb20gJy4vc3JjL3N3aXRjaC1pbnB1dC5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgUmR4U3dpdGNoUm9vdERpcmVjdGl2ZSB9IGZyb20gJy4vc3JjL3N3aXRjaC1yb290LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBSZHhTd2l0Y2hUaHVtYkRpcmVjdGl2ZSB9IGZyb20gJy4vc3JjL3N3aXRjaC10aHVtYi5kaXJlY3RpdmUnO1xuXG5leHBvcnQgKiBmcm9tICcuL3NyYy9zd2l0Y2gtaW5wdXQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3N3aXRjaC1yb290LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9zd2l0Y2gtdGh1bWIuZGlyZWN0aXZlJztcblxuZXhwb3J0IHR5cGUgeyBTd2l0Y2hQcm9wcyB9IGZyb20gJy4vc3JjL3N3aXRjaC1yb290LmRpcmVjdGl2ZSc7XG5cbmNvbnN0IHN3aXRjaEltcG9ydHMgPSBbXG4gICAgUmR4U3dpdGNoUm9vdERpcmVjdGl2ZSxcbiAgICBSZHhTd2l0Y2hJbnB1dERpcmVjdGl2ZSxcbiAgICBSZHhTd2l0Y2hUaHVtYkRpcmVjdGl2ZVxuXTtcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbLi4uc3dpdGNoSW1wb3J0c10sXG4gICAgZXhwb3J0czogWy4uLnN3aXRjaEltcG9ydHNdXG59KVxuZXhwb3J0IGNsYXNzIFJkeFN3aXRjaE1vZHVsZSB7fVxuIl19

package/esm2022/switch/radix-ng-primitives-switch.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFkaXgtbmctcHJpbWl0aXZlcy1zd2l0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL3N3aXRjaC9yYWRpeC1uZy1wcmltaXRpdmVzLXN3aXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==