@radix-ng/primitives 0.18.2 → 0.20.0

package/core/index.d.ts

@@ -1,5 +1,7 @@
 export * from './src/accessor/provide-value-accessor';
 export * from './src/auto-focus.directive';
+export * from './src/control-value-accessor';
+export * from './src/create-inject-context';
 export * from './src/document';
 export * from './src/inject-ng-control';
 export * from './src/is-client';

package/core/src/control-value-accessor/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Based On:
+ * Copyright (c) flebee Authors. Licensed under the MIT License.
+ */
+import { BooleanInput } from '@angular/cdk/coercion';
+import { Injector } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export type RdxControlValueAccessorCompareTo<T = any> = (a?: T, b?: T) => boolean;
+export declare const injectCvaCompareTo: {
+    (): RdxControlValueAccessorCompareTo<any>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false;
+    } & {
+        injector?: Injector;
+    }): RdxControlValueAccessorCompareTo<any>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: Injector;
+    }): RdxControlValueAccessorCompareTo<any> | null;
+}, provideCvaCompareTo: (() => import("@angular/core").Provider) & ((value: RdxControlValueAccessorCompareTo<any> | (() => RdxControlValueAccessorCompareTo<any>), isFunctionValue: boolean) => import("@angular/core").Provider);
+/**
+ * Provides a {@link RdxControlValueAccessorCompareTo comparator} based on a property of `T`.
+ *
+ * @example
+ * ```ts
+ * interface User {
+ * 	id: string;
+ * 	name: string;
+ * }
+ *
+ * provideCvaCompareToByProp<User>('id');
+ * ```
+ */
+export declare const provideCvaCompareToByProp: <T>(prop: keyof T) => import("@angular/core").Provider;
+export declare class RdxControlValueAccessor<Value> implements ControlValueAccessor {
+    private readonly ngControl;
+    private readonly destroyRef;
+    private readonly injector;
+    /**
+     * A comparator, which determines value changes. Should return true, if two values are considered semantic equal.
+     *
+     * Defaults to {@link Object.is} in order to align with change detection behavior for inputs.
+     */
+    readonly compareTo: RdxControlValueAccessorCompareTo<Value>;
+    /** Whether this is disabled. If a control is present, it reflects it's disabled state. */
+    inputDisabled: import("@angular/core").ModelSignal<BooleanInput>;
+    disabled: import("@angular/core").Signal<boolean>;
+    /** The value of this. If a control is present, it reflects it's value. */
+    value: import("@angular/core").ModelSignal<Value>;
+    /**
+     * `NgModel` sets up the control in `ngOnChanges`. Idk if bug or on purpose, but `writeValue` and `setDisabledState` are called before the inputs are set.
+     * {@link https://github.com/angular/angular/blob/main/packages/forms/src/directives/ng_model.ts#L223}
+     *
+     * @ignore
+     */
+    private get registered();
+    constructor();
+    private _onChange;
+    private _onTouched;
+    /**
+     * This function should be called when this host is considered `touched`.
+     *
+     * NOTE: Whenever a `blur` event is triggered on this host, this function is called.
+     *
+     * @see {@link RdxControlValueAccessor.registerOnTouched}
+     * @see {@link RdxControlValueAccessor._ngControl}
+     */
+    markAsTouched(): void;
+    setDisabledState(disabled: boolean): void;
+    writeValue(value: Value): void;
+    registerOnChange(onChange: (value: Value) => void): void;
+    registerOnTouched(onTouched: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxControlValueAccessor<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxControlValueAccessor<any>, never, never, { "inputDisabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "inputDisabled": "disabledChange"; "value": "valueChange"; }, never, never, true, never>;
+}

package/core/src/create-inject-context/assert-injector.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This code is adapted from the original implementation by the ngxTension team.
+ * Source: https://github.com/ngxtension/ngxtension-platform/blob/main/libs/ngxtension/assert-injector/src/assert-injector.ts
+ *
+ * Copyright (c) ngxtension Authors. Licensed under the MIT License.
+ */
+import { Injector } from '@angular/core';
+import { Nullable, SafeFunction } from '../types';
+/**
+ * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
+ * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`
+ * whether it is the default `Injector` within the current **Injection Context**
+ * or the custom `Injector` that was passed in.
+ *
+ * @template {() => unknown} Runner - Runner is a function that can return anything
+ * @param {SafeFunction} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Nullable<Injector>} injector - the optional "custom" Injector
+ * @param {Runner} runner - the runner fn
+ * @returns {ReturnType<Runner>} result - returns the result of the Runner
+ *
+ * @example
+ * ```ts
+ * function injectValue(injector?: Injector) {
+ *  return assertInjector(injectValue, injector, () => 'value');
+ * }
+ *
+ * injectValue(); // string
+ * ```
+ */
+export declare function assertInjector<Runner extends () => unknown>(fn: SafeFunction, injector: Nullable<Injector>, runner: Runner): ReturnType<Runner>;
+/**
+ * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
+ * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`
+ * within the current **Injection Context** or the custom `Injector` that was passed in.
+ *
+ * @param {SafeFunction} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Nullable<Injector>} injector - the optional "custom" Injector
+ * @returns Injector
+ *
+ * @example
+ * ```ts
+ * function injectDestroy(injector?: Injector) {
+ *  injector = assertInjector(injectDestroy, injector);
+ *
+ *  return runInInjectionContext(injector, () => {
+ *    // code
+ *  })
+ * }
+ * ```
+ */
+export declare function assertInjector(fn: SafeFunction, injector: Nullable<Injector>): Injector;

package/core/src/create-inject-context/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ *
+ * Copyright (c) ngxtension Authors. Licensed under the MIT License.
+ */
+import { InjectionToken, type EnvironmentProviders, type Host, type InjectOptions, type Injector, type Optional, type Provider, type Self, type SkipSelf, type Type } from '@angular/core';
+type CreateInjectionTokenDep<TTokenType> = Type<TTokenType> | (abstract new (...args: any[]) => TTokenType) | InjectionToken<TTokenType>;
+type CreateInjectionTokenDeps<TFactory extends (...args: any[]) => any, TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>> = {
+    [Index in keyof TFactoryDeps]: CreateInjectionTokenDep<TFactoryDeps[Index]> | [...modifiers: Array<Optional | Self | SkipSelf | Host>, token: CreateInjectionTokenDep<TFactoryDeps[Index]>];
+} & {
+    length: TFactoryDeps['length'];
+};
+export type CreateInjectionTokenOptions<TFactory extends (...args: any[]) => any, TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>> = (TFactoryDeps[0] extends undefined ? {
+    deps?: never;
+} : {
+    deps: CreateInjectionTokenDeps<TFactory, TFactoryDeps>;
+}) & {
+    isRoot?: boolean;
+    isFunctionValue?: boolean;
+    multi?: boolean;
+    token?: InjectionToken<ReturnType<TFactory>>;
+    extraProviders?: Provider | EnvironmentProviders;
+};
+type InjectFn<TFactoryReturn> = {
+    (): TFactoryReturn;
+    (injectOptions: InjectOptions & {
+        optional?: false;
+    } & {
+        injector?: Injector;
+    }): TFactoryReturn;
+    (injectOptions: InjectOptions & {
+        injector?: Injector;
+    }): TFactoryReturn | null;
+};
+type ProvideFn<TNoop extends boolean, TFactoryReturn, TReturn = TFactoryReturn extends Array<infer Item> ? Item : TFactoryReturn> = (TNoop extends true ? (value: TReturn | (() => TReturn)) => Provider : () => Provider) & (TReturn extends Function ? (value: TReturn | (() => TReturn), isFunctionValue: boolean) => Provider : (value: TReturn | (() => TReturn)) => Provider);
+export type CreateInjectionTokenReturn<TFactoryReturn, TNoop extends boolean = false> = [
+    InjectFn<TFactoryReturn>,
+    ProvideFn<TNoop, TFactoryReturn>,
+    InjectionToken<TFactoryReturn>,
+    () => Provider
+];
+/**
+ * `createInjectionToken` accepts a factory function and returns a tuple of `injectFn`, `provideFn`, and the `InjectionToken`
+ * that the factory function is for.
+ *
+ * @param {Function} factory - Factory Function that returns the value for the `InjectionToken`
+ * @param {CreateInjectionTokenOptions} options - object to control how the `InjectionToken` behaves
+ * @returns {CreateInjectionTokenReturn}
+ *
+ * @example
+ * ```ts
+ * const [injectCounter, provideCounter, COUNTER] = createInjectionToken(() => signal(0));
+ *
+ * export class Counter {
+ *  counter = injectCounter(); // WritableSignal<number>
+ * }
+ * ```
+ */
+export declare function createInjectionToken<TFactory extends (...args: any[]) => any, TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>, TOptions extends CreateInjectionTokenOptions<TFactory, TFactoryDeps> = CreateInjectionTokenOptions<TFactory, TFactoryDeps>, TFactoryReturn = TOptions['multi'] extends true ? Array<ReturnType<TFactory>> : ReturnType<TFactory>>(factory: TFactory, options?: TOptions): CreateInjectionTokenReturn<TFactoryReturn>;
+export declare function createNoopInjectionToken<TValue, TMulti extends boolean = false, TOptions = Pick<CreateInjectionTokenOptions<() => void, []>, 'extraProviders'> & (TValue extends (...args: any[]) => any ? {
+    isFunctionValue: true;
+} : {
+    isFunctionValue?: never;
+}) & (TMulti extends true ? {
+    multi: true;
+} : {
+    multi?: never;
+})>(description: string, options?: TOptions): CreateInjectionTokenReturn<TMulti extends true ? TValue[] : TValue, true>;
+export {};

package/core/src/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Nullable from `Type` adds `null` and `undefined`
+ *
+ * @example ```ts
+ *  // Expect: string | number | undefined | null
+ *  type Value = Nulling<string | number>;
+ * ```
+ */
+export type Nullable<Type> = null | Type | undefined;
+/**
+ * SafeFunction is a type for functions that accept any number of arguments of unknown types
+ * and return a value of an unknown type. This is useful when you want to define a function
+ * without being strict about the input or output types, maintaining flexibility.
+ *
+ * @example ```ts
+ *  const safeFn: SafeFunction = (...args) => {
+ *    return args.length > 0 ? args[0] : null;
+ *  };
+ *
+ *  const result = safeFn(1, 'hello'); // result: 1
+ * ```
+ */
+export type SafeFunction = (...args: unknown[]) => unknown;

package/esm2022/avatar/index.mjs

@@ -2,4 +2,4 @@ export * from './src/avatar-fallback.directive';
 export * from './src/avatar-image.directive';
 export * from './src/avatar-root.directive';
 export * from './src/avatar.config';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL2F2YXRhci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBRWhELGNBQWMsOEJBQThCLENBQUM7QUFFN0MsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zcmMvYXZhdGFyLWZhbGxiYWNrLmRpcmVjdGl2ZSc7XG5leHBvcnQgdHlwZSB7IFJkeEF2YXRhckZhbGxiYWNrUHJvcHMgfSBmcm9tICcuL3NyYy9hdmF0YXItZmFsbGJhY2suZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2F2YXRhci1pbWFnZS5kaXJlY3RpdmUnO1xuZXhwb3J0IHR5cGUgeyBSZHhBdmF0YXJJbWFnZVByb3BzIH0gZnJvbSAnLi9zcmMvYXZhdGFyLWltYWdlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hdmF0YXItcm9vdC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYXZhdGFyLmNvbmZpZyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL2F2YXRhci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zcmMvYXZhdGFyLWZhbGxiYWNrLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hdmF0YXItaW1hZ2UuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2F2YXRhci1yb290LmRpcmVjdGl2ZSc7XG5leHBvcnQgdHlwZSB7IFJkeEltYWdlTG9hZGluZ1N0YXR1cyB9IGZyb20gJy4vc3JjL2F2YXRhci1yb290LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hdmF0YXIuY29uZmlnJztcbiJdfQ==

package/esm2022/avatar/src/avatar-fallback.directive.mjs

@@ -1,62 +1,60 @@
-import { isPlatformBrowser } from '@angular/common';
-import { Directive, inject, Input, NgZone, numberAttribute, PLATFORM_ID, signal } from '@angular/core';
-import { injectAvatar } from './avatar-root.directive';
+import { Directive, effect, inject, input, signal } from '@angular/core';
+import { RdxAvatarRootContext } from './avatar-root.directive';
 import { injectAvatarConfig } from './avatar.config';
 import * as i0 from "@angular/core";
 export class RdxAvatarFallbackDirective {
     constructor() {
-        this.avatar = injectAvatar();
+        this.avatarRoot = inject(RdxAvatarRootContext);
         this.config = injectAvatarConfig();
-        this.ngZone = inject(NgZone);
-        this.platformId = inject(PLATFORM_ID);
-        /**
-         * Define a delay before the fallback is shown.
-         * This is useful to only show the fallback for those with slower connections.
-         * @default 0
-         */
-        this.delayMs = this.config.delayMs;
-        this.visible = signal(false);
-        /**
-         * Determine the delay has elapsed, and we can show the fallback.
-         */
-        this.delayElapsed = false;
+        this.delayMs = input(this.config.delayMs);
+        this.canRender = signal(false);
         this.timeoutId = null;
+        effect(() => {
+            const status = this.avatarRoot.imageLoadingStatus();
+            if (status === 'loading') {
+                this.startDelayTimer();
+            }
+            else {
+                this.clearDelayTimer();
+                this.canRender.set(false);
+            }
+        }, { allowSignalWrites: true });
     }
-    ngOnInit() {
-        if (isPlatformBrowser(this.platformId)) {
-            this.ngZone.runOutsideAngular(() => {
-                this.timeoutId = globalThis.setTimeout(() => {
-                    this.ngZone.run(() => {
-                        this.delayElapsed = true;
-                        this.updateVisibility();
-                    });
-                }, this.delayMs);
-            });
+    get shouldRender() {
+        return this.canRender() && this.avatarRoot.imageLoadingStatus() !== 'loaded';
+    }
+    startDelayTimer() {
+        this.clearDelayTimer();
+        if (this.delayMs() > 0) {
+            this.timeoutId = setTimeout(() => {
+                this.canRender.set(true);
+            }, this.delayMs());
+        }
+        else {
+            this.canRender.set(true);
         }
     }
-    ngOnDestroy() {
-        if (isPlatformBrowser(this.platformId) && this.timeoutId !== null) {
-            globalThis.clearTimeout(this.timeoutId);
+    clearDelayTimer() {
+        if (this.timeoutId !== null) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
         }
     }
-    updateVisibility() {
-        this.visible.set(this.delayElapsed && this.avatar._state() !== 'loaded');
+    ngOnDestroy() {
+        this.clearDelayTimer();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarFallbackDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.11", type: RdxAvatarFallbackDirective, isStandalone: true, selector: "span[rdxAvatarFallback]", inputs: { delayMs: ["rdxDelayMs", "delayMs", numberAttribute] }, host: { properties: { "style.display": "visible() ? null : \"none\"" } }, exportAs: ["rdxAvatarFallback"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.11", type: RdxAvatarFallbackDirective, isStandalone: true, selector: "span[rdxAvatarFallback]", inputs: { delayMs: { classPropertyName: "delayMs", publicName: "delayMs", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "style.display": "shouldRender ? null : \"none\" " } }, exportAs: ["rdxAvatarFallback"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarFallbackDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: 'span[rdxAvatarFallback]',
-                    exportAs: 'rdxAvatarFallback',
                     standalone: true,
+                    exportAs: 'rdxAvatarFallback',
                     host: {
-                        '[style.display]': 'visible() ? null : "none"'
+                        '[style.display]': 'shouldRender ? null : "none" '
                     }
                 }]
-        }], propDecorators: { delayMs: [{
-                type: Input,
-                args: [{ alias: 'rdxDelayMs', transform: numberAttribute }]
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/avatar/src/avatar-image.directive.mjs

@@ -1,53 +1,52 @@
-import { Directive, ElementRef, EventEmitter, inject, Output } from '@angular/core';
-import { injectAvatar } from './avatar-root.directive';
+import { computed, Directive, ElementRef, inject, input, output } from '@angular/core';
+import { RdxAvatarRootContext } from './avatar-root.directive';
 import * as i0 from "@angular/core";
 export class RdxAvatarImageDirective {
     constructor() {
-        this.avatar = injectAvatar();
-        this.elementRef = inject(ElementRef);
-        /**
-         * By default, it will only render when it has loaded.
-         * You can use the `onLoadingStatusChange` handler if you need more control.
-         */
-        this.onLoadingStatusChange = new EventEmitter();
+        this.avatarRoot = inject(RdxAvatarRootContext);
+        this.elementRef = inject((ElementRef));
+        this.src = (input.required);
+        this.onLoadingStatusChange = output();
+        this.imageLoadingStatus = computed(() => this.avatarRoot.imageLoadingStatus());
     }
     ngOnInit() {
-        this.avatar._setState('loading');
         if (!this.nativeElement.src) {
-            this.avatar._setState('error');
+            this.setImageStatus('error');
         }
-        if (this.nativeElement.complete) {
-            this.avatar._setState('loaded');
+        else if (this.nativeElement.complete) {
+            this.setImageStatus('loaded');
+        }
+        else {
+            this.setImageStatus('loading');
         }
-        this.onLoadingStatusChange.emit(this.avatar._state());
     }
     onLoad() {
-        this.avatar._setState('loaded');
-        this.onLoadingStatusChange.emit('loaded');
+        this.setImageStatus('loaded');
     }
     onError() {
-        this.avatar._setState('error');
-        this.onLoadingStatusChange.emit('error');
+        this.setImageStatus('error');
+    }
+    setImageStatus(status) {
+        this.avatarRoot.imageLoadingStatus.set(status);
+        this.onLoadingStatusChange.emit(status);
     }
     get nativeElement() {
         return this.elementRef.nativeElement;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarImageDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.11", type: RdxAvatarImageDirective, isStandalone: true, selector: "img[rdxAvatarImage]", outputs: { onLoadingStatusChange: "onLoadingStatusChange" }, host: { attributes: { "role": "img" }, listeners: { "load": "onLoad()", "error": "onError()" } }, exportAs: ["rdxAvatarImage"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.11", type: RdxAvatarImageDirective, isStandalone: true, selector: "img[rdxAvatarImage]", outputs: { onLoadingStatusChange: "onLoadingStatusChange" }, host: { listeners: { "load": "onLoad()", "error": "onError()" }, properties: { "style.display": "(imageLoadingStatus() === \"loaded\")? null : \"none\"" } }, exportAs: ["rdxAvatarImage"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarImageDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: 'img[rdxAvatarImage]',
-                    exportAs: 'rdxAvatarImage',
                     standalone: true,
+                    exportAs: 'rdxAvatarImage',
                     host: {
-                        role: 'img',
                         '(load)': 'onLoad()',
-                        '(error)': 'onError()'
+                        '(error)': 'onError()',
+                        '[style.display]': '(imageLoadingStatus() === "loaded")? null : "none"'
                     }
                 }]
-        }], propDecorators: { onLoadingStatusChange: [{
-                type: Output
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,30 +1,18 @@
-import { Directive, inject, InjectionToken, signal } from '@angular/core';
+import { Directive, Injectable, signal } from '@angular/core';
 import * as i0 from "@angular/core";
-const RdxAvatarToken = new InjectionToken('RdxAvatarToken');
-export function injectAvatar() {
-    return inject(RdxAvatarToken);
-}
-export class RdxAvatarRootDirective {
+export class RdxAvatarRootContext {
     constructor() {
-        /**
-         * A readonly signal property that holds the current state of image loading.
-         * To set a new status, use the `setState` method of the component.
-         * @internal
-         */
-        this._state = signal('idle');
-    }
-    /**
-     * Set the avatar state.
-     * @param state The new image loading status to set. This value should be one of the predefined states
-     *              in the `ImageLoadingStatus`
-     * @returns void This method does not return a value.
-     * @internal
-     */
-    _setState(state) {
-        this._state.set(state);
+        this.imageLoadingStatus = signal('loading');
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarRootContext, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarRootContext }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarRootContext, decorators: [{
+            type: Injectable
+        }] });
+export class RdxAvatarRootDirective {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarRootDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.11", type: RdxAvatarRootDirective, isStandalone: true, selector: "span[rdxAvatarRoot]", providers: [{ provide: RdxAvatarToken, useExisting: RdxAvatarRootDirective }], exportAs: ["rdxAvatarRoot"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.11", type: RdxAvatarRootDirective, isStandalone: true, selector: "span[rdxAvatarRoot]", providers: [RdxAvatarRootContext], exportAs: ["rdxAvatarRoot"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxAvatarRootDirective, decorators: [{
             type: Directive,
@@ -32,7 +20,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImpo
                     selector: 'span[rdxAvatarRoot]',
                     exportAs: 'rdxAvatarRoot',
                     standalone: true,
-                    providers: [{ provide: RdxAvatarToken, useExisting: RdxAvatarRootDirective }]
+                    providers: [RdxAvatarRootContext]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZhdGFyLXJvb3QuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcHJpbWl0aXZlcy9hdmF0YXIvc3JjL2F2YXRhci1yb290LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxjQUFjLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUUxRSxNQUFNLGNBQWMsR0FBRyxJQUFJLGNBQWMsQ0FBeUIsZ0JBQWdCLENBQUMsQ0FBQztBQUVwRixNQUFNLFVBQVUsWUFBWTtJQUN4QixPQUFPLE1BQU0sQ0FBQyxjQUFjLENBQUMsQ0FBQztBQUNsQyxDQUFDO0FBVUQsTUFBTSxPQUFPLHNCQUFzQjtJQU5uQztRQU9JOzs7O1dBSUc7UUFDTSxXQUFNLEdBQUcsTUFBTSxDQUF3QixNQUFNLENBQUMsQ0FBQztLQVkzRDtJQVZHOzs7Ozs7T0FNRztJQUNILFNBQVMsQ0FBQyxLQUE0QjtRQUNsQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMzQixDQUFDOytHQWpCUSxzQkFBc0I7bUdBQXRCLHNCQUFzQixrRUFGcEIsQ0FBQyxFQUFFLE9BQU8sRUFBRSxjQUFjLEVBQUUsV0FBVyxFQUFFLHNCQUFzQixFQUFFLENBQUM7OzRGQUVwRSxzQkFBc0I7a0JBTmxDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHFCQUFxQjtvQkFDL0IsUUFBUSxFQUFFLGVBQWU7b0JBQ3pCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixTQUFTLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxjQUFjLEVBQUUsV0FBVyx3QkFBd0IsRUFBRSxDQUFDO2lCQUNoRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgaW5qZWN0LCBJbmplY3Rpb25Ub2tlbiwgc2lnbmFsIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmNvbnN0IFJkeEF2YXRhclRva2VuID0gbmV3IEluamVjdGlvblRva2VuPFJkeEF2YXRhclJvb3REaXJlY3RpdmU+KCdSZHhBdmF0YXJUb2tlbicpO1xuXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0QXZhdGFyKCk6IFJkeEF2YXRhclJvb3REaXJlY3RpdmUge1xuICAgIHJldHVybiBpbmplY3QoUmR4QXZhdGFyVG9rZW4pO1xufVxuXG5leHBvcnQgdHlwZSBSZHhJbWFnZUxvYWRpbmdTdGF0dXMgPSAnaWRsZScgfCAnbG9hZGluZycgfCAnbG9hZGVkJyB8ICdlcnJvcic7XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnc3BhbltyZHhBdmF0YXJSb290XScsXG4gICAgZXhwb3J0QXM6ICdyZHhBdmF0YXJSb290JyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIHByb3ZpZGVyczogW3sgcHJvdmlkZTogUmR4QXZhdGFyVG9rZW4sIHVzZUV4aXN0aW5nOiBSZHhBdmF0YXJSb290RGlyZWN0aXZlIH1dXG59KVxuZXhwb3J0IGNsYXNzIFJkeEF2YXRhclJvb3REaXJlY3RpdmUge1xuICAgIC8qKlxuICAgICAqIEEgcmVhZG9ubHkgc2lnbmFsIHByb3BlcnR5IHRoYXQgaG9sZHMgdGhlIGN1cnJlbnQgc3RhdGUgb2YgaW1hZ2UgbG9hZGluZy5cbiAgICAgKiBUbyBzZXQgYSBuZXcgc3RhdHVzLCB1c2UgdGhlIGBzZXRTdGF0ZWAgbWV0aG9kIG9mIHRoZSBjb21wb25lbnQuXG4gICAgICogQGludGVybmFsXG4gICAgICovXG4gICAgcmVhZG9ubHkgX3N0YXRlID0gc2lnbmFsPFJkeEltYWdlTG9hZGluZ1N0YXR1cz4oJ2lkbGUnKTtcblxuICAgIC8qKlxuICAgICAqIFNldCB0aGUgYXZhdGFyIHN0YXRlLlxuICAgICAqIEBwYXJhbSBzdGF0ZSBUaGUgbmV3IGltYWdlIGxvYWRpbmcgc3RhdHVzIHRvIHNldC4gVGhpcyB2YWx1ZSBzaG91bGQgYmUgb25lIG9mIHRoZSBwcmVkZWZpbmVkIHN0YXRlc1xuICAgICAqICAgICAgICAgICAgICBpbiB0aGUgYEltYWdlTG9hZGluZ1N0YXR1c2BcbiAgICAgKiBAcmV0dXJucyB2b2lkIFRoaXMgbWV0aG9kIGRvZXMgbm90IHJldHVybiBhIHZhbHVlLlxuICAgICAqIEBpbnRlcm5hbFxuICAgICAqL1xuICAgIF9zZXRTdGF0ZShzdGF0ZTogUmR4SW1hZ2VMb2FkaW5nU3RhdHVzKTogdm9pZCB7XG4gICAgICAgIHRoaXMuX3N0YXRlLnNldChzdGF0ZSk7XG4gICAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZhdGFyLXJvb3QuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcHJpbWl0aXZlcy9hdmF0YXIvc3JjL2F2YXRhci1yb290LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzlELE1BQU0sT0FBTyxvQkFBb0I7SUFEakM7UUFFYSx1QkFBa0IsR0FBRyxNQUFNLENBQXdCLFNBQVMsQ0FBQyxDQUFDO0tBQzFFOytHQUZZLG9CQUFvQjttSEFBcEIsb0JBQW9COzs0RkFBcEIsb0JBQW9CO2tCQURoQyxVQUFVOztBQVdYLE1BQU0sT0FBTyxzQkFBc0I7K0dBQXRCLHNCQUFzQjttR0FBdEIsc0JBQXNCLGtFQUZwQixDQUFDLG9CQUFvQixDQUFDOzs0RkFFeEIsc0JBQXNCO2tCQU5sQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxxQkFBcUI7b0JBQy9CLFFBQVEsRUFBRSxlQUFlO29CQUN6QixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsU0FBUyxFQUFFLENBQUMsb0JBQW9CLENBQUM7aUJBQ3BDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBJbmplY3RhYmxlLCBzaWduYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IHR5cGUgUmR4SW1hZ2VMb2FkaW5nU3RhdHVzID0gJ2lkbGUnIHwgJ2xvYWRpbmcnIHwgJ2xvYWRlZCcgfCAnZXJyb3InO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgUmR4QXZhdGFyUm9vdENvbnRleHQge1xuICAgIHJlYWRvbmx5IGltYWdlTG9hZGluZ1N0YXR1cyA9IHNpZ25hbDxSZHhJbWFnZUxvYWRpbmdTdGF0dXM+KCdsb2FkaW5nJyk7XG59XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnc3BhbltyZHhBdmF0YXJSb290XScsXG4gICAgZXhwb3J0QXM6ICdyZHhBdmF0YXJSb290JyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIHByb3ZpZGVyczogW1JkeEF2YXRhclJvb3RDb250ZXh0XVxufSlcbmV4cG9ydCBjbGFzcyBSZHhBdmF0YXJSb290RGlyZWN0aXZlIHt9XG4iXX0=

package/esm2022/checkbox/index.mjs

@@ -1,6 +1,36 @@
+import { NgModule } from '@angular/core';
+import { RdxCheckboxButtonDirective } from './src/checkbox-button.directive';
+import { RdxCheckboxIndicatorDirective } from './src/checkbox-indicator.directive';
+import { RdxCheckboxInputDirective } from './src/checkbox-input.directive';
+import { RdxCheckboxDirective } from './src/checkbox.directive';
+import * as i0 from "@angular/core";
 export * from './src/checkbox-button.directive';
 export * from './src/checkbox-indicator.directive';
 export * from './src/checkbox-input.directive';
 export * from './src/checkbox.directive';
 export * from './src/checkbox.token';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wcmltaXRpdmVzL2NoZWNrYm94L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3JjL2NoZWNrYm94LWJ1dHRvbi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvY2hlY2tib3gtaW5kaWNhdG9yLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9jaGVja2JveC1pbnB1dC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvY2hlY2tib3guZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2NoZWNrYm94LnRva2VuJztcbiJdfQ==
+const _imports = [
+    RdxCheckboxInputDirective,
+    RdxCheckboxDirective,
+    RdxCheckboxButtonDirective,
+    RdxCheckboxIndicatorDirective
+];
+export class RdxCheckboxModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxCheckboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.11", ngImport: i0, type: RdxCheckboxModule, imports: [RdxCheckboxInputDirective,
+            RdxCheckboxDirective,
+            RdxCheckboxButtonDirective,
+            RdxCheckboxIndicatorDirective], exports: [RdxCheckboxInputDirective,
+            RdxCheckboxDirective,
+            RdxCheckboxButtonDirective,
+            RdxCheckboxIndicatorDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxCheckboxModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxCheckboxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [..._imports],
+                    exports: [..._imports]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/checkbox/src/checkbox-button.directive.mjs

@@ -8,13 +8,13 @@ export class RdxCheckboxButtonDirective {
         this.elementId = computed(() => (this.id() ? this.id() : `rdx-checkbox-${this.id()}`));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxCheckboxButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.11", type: RdxCheckboxButtonDirective, isStandalone: true, selector: "button[CheckboxButton]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button", "role": "checkbox", "tabindex": "-1" }, properties: { "checked": "checkbox.checked", "disabled": "checkbox.disabled", "required": "checkbox.required", "attr.id": "elementId()", "attr.aria-checked": "checkbox.indeterminate ? \"mixed\" : checkbox.checked", "attr.aria-required": "checkbox.required ? \"\" : null", "attr.data-state": "checkbox.state", "attr.data-disabled": "checkbox.disabled ? \"\" : null" } }, ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.11", type: RdxCheckboxButtonDirective, isStandalone: true, selector: "button[rdxCheckboxButton]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button", "role": "checkbox", "tabindex": "-1" }, properties: { "checked": "checkbox.checked", "disabled": "checkbox.disabled", "required": "checkbox.required", "attr.id": "elementId()", "attr.aria-checked": "checkbox.indeterminate ? \"mixed\" : checkbox.checked", "attr.aria-required": "checkbox.required ? \"\" : null", "attr.data-state": "checkbox.state", "attr.data-disabled": "checkbox.disabled ? \"\" : null" } }, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImport: i0, type: RdxCheckboxButtonDirective, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
-                    selector: 'button[CheckboxButton]',
+                    selector: 'button[rdxCheckboxButton]',
                     host: {
                         type: 'button',
                         role: 'checkbox',
@@ -30,4 +30,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.11", ngImpo
                     }
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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