ng-primitives 0.89.0 → 0.90.0

package/date-time/index.d.ts

@@ -1,3 +1,289 @@
-export { NgpDateAdapter, NgpDateUnits, NgpDuration } from './date-adapter/date-adapter';
-export { injectDateAdapter, provideDateAdapter } from './date-adapter/date-adapter-token';
-export { NgpNativeDateAdapter } from './native-date-adapter/native-date-adapter';
+import { Type, ClassProvider } from '@angular/core';
+
+/**
+ * An abstraction that can be used to create and modify date time objects
+ * immutably regardless of the underlying implementation.
+ */
+interface NgpDateAdapter<T> {
+    /**
+     * Create a new date time object.
+     */
+    create(values: NgpDateUnits): T;
+    /**
+     * Create a new date with the current date and time.
+     */
+    now(): T;
+    /**
+     * Set the year of the date time object based on a duration.
+     */
+    set(date: T, values: NgpDateUnits): T;
+    /**
+     * Add a duration to the date time object.
+     */
+    add(date: T, duration: NgpDuration): T;
+    /**
+     * Subtract a duration from the date time object.
+     */
+    subtract(date: T, duration: NgpDuration): T;
+    /**
+     * Compare two date time objects.
+     */
+    compare(a: T, b: T): number;
+    /**
+     * Determine if two date time objects are equal.
+     */
+    isEqual(a: T, b: T): boolean;
+    /**
+     * Determine if a date time object is before another.
+     */
+    isBefore(a: T, b: T): boolean;
+    /**
+     * Determine if a date time object is after another.
+     */
+    isAfter(a: T, b: T): boolean;
+    /**
+     * Determine if two date objects are on the same day.
+     */
+    isSameDay(a: T, b: T): boolean;
+    /**
+     * Determine if two date objects are on the same month.
+     */
+    isSameMonth(a: T, b: T): boolean;
+    /**
+     * Determine if two date objects are on the same year.
+     */
+    isSameYear(a: T, b: T): boolean;
+    /**
+     * Get the year.
+     */
+    getYear(date: T): number;
+    /**
+     * Get the month.
+     */
+    getMonth(date: T): number;
+    /**
+     * Get the date.
+     */
+    getDate(date: T): number;
+    /**
+     * Get the day of the week as a number (1-7).
+     * - `1` = Monday
+     * - `2` = Tuesday
+     * - `3` = Wednesday
+     * - `4` = Thursday
+     * - `5` = Friday
+     * - `6` = Saturday
+     * - `7` = Sunday
+     */
+    getDay(date: T): number;
+    /**
+     * Get the hours.
+     */
+    getHours(date: T): number;
+    /**
+     * Get the minutes.
+     */
+    getMinutes(date: T): number;
+    /**
+     * Get the seconds.
+     */
+    getSeconds(date: T): number;
+    /**
+     * Get the milliseconds.
+     */
+    getMilliseconds(date: T): number;
+    /**
+     * Get the first day of the month.
+     */
+    startOfMonth(date: T): T;
+    /**
+     * Get the last day of the month.
+     */
+    endOfMonth(date: T): T;
+    /**
+     * Get the start of the day.
+     */
+    startOfDay(date: T): T;
+    /**
+     * Get the end of the day.
+     */
+    endOfDay(date: T): T;
+}
+interface NgpDateUnits {
+    /**
+     * The year.
+     */
+    year?: number;
+    /**
+     * The month 1-12.
+     */
+    month?: number;
+    /**
+     * The day.
+     */
+    day?: number;
+    /**
+     * The hour.
+     */
+    hour?: number;
+    /**
+     * The minute.
+     */
+    minute?: number;
+    /**
+     * The second.
+     */
+    second?: number;
+    /**
+     * The millisecond.
+     */
+    millisecond?: number;
+}
+interface NgpDuration {
+    /**
+     * The years.
+     */
+    years?: number;
+    /**
+     * The months.
+     */
+    months?: number;
+    /**
+     * The days.
+     */
+    days?: number;
+    /**
+     * The hours.
+     */
+    hours?: number;
+    /**
+     * The minutes.
+     */
+    minutes?: number;
+    /**
+     * The seconds.
+     */
+    seconds?: number;
+    /**
+     * The milliseconds.
+     */
+    milliseconds?: number;
+}
+
+/**
+ * Inject the DateAdapter instance
+ */
+declare function injectDateAdapter<T>(): NgpDateAdapter<T>;
+/**
+ * Provide the DateAdapter instance
+ */
+declare function provideDateAdapter<T>(adapter: Type<NgpDateAdapter<T>>): ClassProvider;
+
+declare class NgpNativeDateAdapter implements NgpDateAdapter<Date> {
+    /**
+     * Create a new date time object.
+     */
+    create({ day, hour, minute, month, second, year, millisecond }: NgpDateUnits): Date;
+    /**
+     * Create a new date with the current date and time.
+     */
+    now(): Date;
+    /**
+     * Set the year of the date time object based on a duration.
+     */
+    set(date: Date, values: NgpDateUnits): Date;
+    /**
+     * Add a duration to the date time object.
+     */
+    add(date: Date, duration: NgpDuration): Date;
+    /**
+     * Subtract a duration from the date time object
+     */
+    subtract(date: Date, duration: NgpDuration): Date;
+    /**
+     * Compare two date time objects
+     */
+    compare(a: Date, b: Date): number;
+    /**
+     * Determine if two date time objects are equal.
+     */
+    isEqual(a: Date, b: Date): boolean;
+    /**
+     * Determine if a date time object is before another.
+     */
+    isBefore(a: Date, b: Date): boolean;
+    /**
+     * Determine if a date time object is after another.
+     */
+    isAfter(a: Date, b: Date): boolean;
+    /**
+     * Determine if two date objects are on the same day.
+     */
+    isSameDay(a: Date, b: Date): boolean;
+    /**
+     * Determine if two date objects are on the same month.
+     */
+    isSameMonth(a: Date, b: Date): boolean;
+    /**
+     * Determine if two date objects are on the same year.
+     */
+    isSameYear(a: Date, b: Date): boolean;
+    /**
+     * Get the year.
+     */
+    getYear(date: Date): number;
+    /**
+     * Get the month.
+     */
+    getMonth(date: Date): number;
+    /**
+     * Get the day of the week as a number (1-7).
+     * - `1` = Monday
+     * - `2` = Tuesday
+     * - `3` = Wednesday
+     * - `4` = Thursday
+     * - `5` = Friday
+     * - `6` = Saturday
+     * - `7` = Sunday
+     */
+    getDay(date: Date): number;
+    /**
+     * Get the date.
+     */
+    getDate(date: Date): number;
+    /**
+     * Get the hours.
+     */
+    getHours(date: Date): number;
+    /**
+     * Get the minutes.
+     */
+    getMinutes(date: Date): number;
+    /**
+     * Get the seconds.
+     */
+    getSeconds(date: Date): number;
+    /**
+     * Get the milliseconds.
+     */
+    getMilliseconds(date: Date): number;
+    /**
+     * Get the first day of the month.
+     */
+    startOfMonth(date: Date): Date;
+    /**
+     * Get the last day of the month.
+     */
+    endOfMonth(date: Date): Date;
+    /**
+     * Get the start of the day.
+     */
+    startOfDay(date: Date): Date;
+    /**
+     * Get the end of the day.
+     */
+    endOfDay(date: Date): Date;
+}
+
+export { NgpNativeDateAdapter, injectDateAdapter, provideDateAdapter };
+export type { NgpDateAdapter, NgpDateUnits, NgpDuration };

package/date-time-luxon/index.d.ts

@@ -1 +1,31 @@
-export * from './luxon-date-adapter/luxon-date-adapter';
+import { DateTime } from 'luxon';
+import { NgpDateAdapter, NgpDateUnits, NgpDuration } from 'ng-primitives/date-time';
+
+declare class NgpLuxonDateAdapter implements NgpDateAdapter<DateTime> {
+    now(): DateTime<true>;
+    set(date: DateTime, values: NgpDateUnits): DateTime<boolean>;
+    add(date: DateTime, duration: NgpDuration): DateTime<boolean>;
+    subtract(date: DateTime, duration: NgpDuration): DateTime<boolean>;
+    compare(a: DateTime, b: DateTime): number;
+    isEqual(a: DateTime, b: DateTime): boolean;
+    isBefore(a: DateTime, b: DateTime): boolean;
+    isAfter(a: DateTime, b: DateTime): boolean;
+    isSameDay(a: DateTime, b: DateTime): boolean;
+    isSameMonth(a: DateTime, b: DateTime): boolean;
+    isSameYear(a: DateTime, b: DateTime): boolean;
+    getYear(date: DateTime): number;
+    getMonth(date: DateTime): number;
+    getDate(date: DateTime): number;
+    getDay(date: DateTime): number;
+    getHours(date: DateTime): number;
+    getMinutes(date: DateTime): number;
+    getSeconds(date: DateTime): number;
+    getMilliseconds(date: DateTime): number;
+    startOfMonth(date: DateTime): DateTime<boolean>;
+    endOfMonth(date: DateTime): DateTime<boolean>;
+    startOfDay(date: DateTime): DateTime<boolean>;
+    endOfDay(date: DateTime): DateTime<boolean>;
+    create(values: NgpDateUnits): DateTime<true> | DateTime<false>;
+}
+
+export { NgpLuxonDateAdapter };

package/dialog/index.d.ts

@@ -1,9 +1,253 @@
-export { NgpDialogConfig, provideDialogConfig } from './config/dialog-config';
-export { NgpDialogDescription } from './dialog-description/dialog-description';
-export { NgpDialogOverlay } from './dialog-overlay/dialog-overlay';
-export { NgpDialogTitle } from './dialog-title/dialog-title';
-export { NgpDialogTrigger } from './dialog-trigger/dialog-trigger';
-export { NgpDialog } from './dialog/dialog';
-export { injectDialogRef, NgpDialogRef } from './dialog/dialog-ref';
-export { injectDialogState, provideDialogState } from './dialog/dialog-state';
-export { NgpDialogManager } from './dialog/dialog.service';
+import { ScrollStrategy, OverlayRef } from '@angular/cdk/overlay';
+import * as _angular_core from '@angular/core';
+import { ViewContainerRef, Injector, Provider, OnDestroy, TemplateRef, Type } from '@angular/core';
+import * as i1 from 'ng-primitives/internal';
+import { Subject, Observable } from 'rxjs';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import * as ng_primitives_state from 'ng-primitives/state';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1$1 from 'ng-primitives/focus-trap';
+
+/** Valid ARIA roles for a dialog. */
+type NgpDialogRole = 'dialog' | 'alertdialog';
+interface NgpDialogConfig<T = any> {
+    /** The view container to attach the dialog to. */
+    viewContainerRef?: ViewContainerRef;
+    /** The injector to use for the dialog. Defaults to the view container's injector.*/
+    injector?: Injector;
+    /** ID for the dialog. If omitted, a unique one will be generated. */
+    id?: string;
+    /** The role of the dialog. */
+    role?: NgpDialogRole;
+    /** Whether this is a modal dialog. Used to set the `aria-modal` attribute. */
+    modal?: boolean;
+    /** Scroll strategy to be used for the dialog. This determines how the dialog responds to scrolling underneath the panel element. */
+    scrollStrategy?: ScrollStrategy;
+    /**
+     * Whether the dialog should close when the user navigates backwards or forwards through browser
+     * history.
+     */
+    closeOnNavigation?: boolean;
+    /** Whether the dialog should close when the user presses the escape key. */
+    closeOnEscape?: boolean;
+    /** Whether the dialog should close when the user click the overlay. */
+    closeOnClick?: boolean;
+    data?: T;
+}
+/**
+ * Provide the default Dialog configuration
+ * @param config The Dialog configuration
+ * @returns The provider
+ */
+declare function provideDialogConfig(config: Partial<NgpDialogConfig>): Provider[];
+
+declare class NgpDialogDescription implements OnDestroy {
+    /** Access the dialog */
+    private readonly dialog;
+    /** The id of the descriptions. */
+    readonly id: _angular_core.InputSignal<string>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpDialogDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpDialogDescription, "[ngpDialogDescription]", ["ngpDialogDescription"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgpDialogOverlay {
+    /** Access the global configuration */
+    private readonly config;
+    /** Access the dialog ref. */
+    private readonly dialogRef;
+    /**
+     * Whether the dialog should close on backdrop click.
+     * @default `true`
+     */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpDialogOverlay, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpDialogOverlay, "[ngpDialogOverlay]", ["ngpDialogOverlay"], { "closeOnClick": { "alias": "ngpDialogOverlayCloseOnClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpExitAnimation; inputs: {}; outputs: {}; }]>;
+}
+
+declare class NgpDialogTitle implements OnDestroy {
+    /** Access the dialog. */
+    private readonly dialog;
+    /** The id of the title. */
+    readonly id: _angular_core.InputSignal<string>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpDialogTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpDialogTitle, "[ngpDialogTitle]", ["ngpDialogTitle"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Reference to a dialog opened via the Dialog service.
+ */
+declare class NgpDialogRef<T = unknown, R = unknown> {
+    readonly overlayRef: OverlayRef;
+    readonly config: NgpDialogConfig<T>;
+    /** Whether the user is allowed to close the dialog. */
+    disableClose: boolean | undefined;
+    /** Whether the escape key is allowed to close the dialog. */
+    closeOnEscape: boolean | undefined;
+    /** Emits when the dialog has been closed. */
+    readonly closed: Subject<{
+        focusOrigin?: FocusOrigin;
+        result?: R;
+    }>;
+    /** Emits when on keyboard events within the dialog. */
+    readonly keydownEvents: Observable<KeyboardEvent>;
+    /** Emits on pointer events that happen outside of the dialog. */
+    readonly outsidePointerEvents: Observable<MouseEvent>;
+    /** Data passed from the dialog opener. */
+    readonly data?: T;
+    /** Unique ID for the dialog. */
+    readonly id: string;
+    /** Subscription to external detachments of the dialog. */
+    private detachSubscription;
+    /** @internal Store the injector */
+    injector: Injector | undefined;
+    /** Whether the dialog is closing. */
+    private closing;
+    constructor(overlayRef: OverlayRef, config: NgpDialogConfig<T>);
+    /**
+     * Close the dialog.
+     * @param result Optional result to return to the dialog opener.
+     * @param options Additional options to customize the closing behavior.
+     */
+    close(result?: R, focusOrigin?: FocusOrigin): Promise<void>;
+    /** Updates the position of the dialog based on the current position strategy. */
+    updatePosition(): this;
+}
+declare function injectDialogRef<T = unknown, R = unknown>(): NgpDialogRef<T, R>;
+
+/**
+ * This is based on the Angular CDK Dialog service.
+ * https://github.com/angular/components/blob/main/src/cdk/dialog/dialog.ts
+ */
+declare class NgpDialogManager implements OnDestroy {
+    private readonly applicationRef;
+    private readonly document;
+    private readonly overlay;
+    private readonly focusMonitor;
+    private readonly defaultOptions;
+    private readonly parentDialogManager;
+    private readonly overlayContainer;
+    private readonly scrollStrategy;
+    private openDialogsAtThisLevel;
+    private readonly afterAllClosedAtThisLevel;
+    private readonly afterOpenedAtThisLevel;
+    private ariaHiddenElements;
+    /** Keeps track of the currently-open dialogs. */
+    get openDialogs(): readonly NgpDialogRef[];
+    /** Stream that emits when a dialog has been opened. */
+    get afterOpened(): Subject<NgpDialogRef>;
+    /**
+     * Stream that emits when all open dialog have finished closing.
+     * Will emit on subscribe if there are no open dialogs to begin with.
+     */
+    readonly afterAllClosed: Observable<void>;
+    /**
+     * Opens a modal dialog containing the given template.
+     */
+    open<T, R>(templateRefOrComponentType: TemplateRef<NgpDialogContext<T, R>> | Type<unknown>, config?: NgpDialogConfig<T>): NgpDialogRef<T, R>;
+    /**
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll(): void;
+    /**
+     * Finds an open dialog by its id.
+     * @param id ID to use when looking up the dialog.
+     */
+    getDialogById(id: string): NgpDialogRef | undefined;
+    ngOnDestroy(): void;
+    /**
+     * Creates an overlay config from a dialog config.
+     */
+    private getOverlayConfig;
+    /**
+     * Creates a custom injector to be used inside the dialog. This allows a component loaded inside
+     * of a dialog to close itself and, optionally, to return a value.
+     */
+    private createInjector;
+    /**
+     * Removes a dialog from the array of open dialogs.
+     */
+    private removeOpenDialog;
+    /** Hides all of the content that isn't an overlay from assistive technology. */
+    private hideNonDialogContentFromAssistiveTechnology;
+    private getAfterAllClosed;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpDialogManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgpDialogManager>;
+}
+interface NgpDialogContext<T = unknown, R = unknown> {
+    $implicit: NgpDialogRef<T, R>;
+    close: (result?: R) => void;
+}
+
+declare class NgpDialogTrigger<T = unknown> {
+    /** Access the global configuration */
+    private readonly config;
+    /** Access the dialog manager. */
+    private readonly dialogManager;
+    /** The template to launch. */
+    readonly template: _angular_core.InputSignal<TemplateRef<NgpDialogContext<unknown, unknown>>>;
+    /** Emits whenever the dialog is closed with the given result. */
+    readonly closed: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Whether the dialog should close on escape.
+     * @default `true`
+     */
+    readonly closeOnEscape: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Store the dialog ref.
+     * @internal
+     */
+    private dialogRef;
+    protected launch(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpDialogTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpDialogTrigger<any>, "[ngpDialogTrigger]", ["ngpDialogTrigger"], { "template": { "alias": "ngpDialogTrigger"; "required": true; "isSignal": true; }; "closeOnEscape": { "alias": "ngpDialogTriggerCloseOnEscape"; "required": false; "isSignal": true; }; }, { "closed": "ngpDialogTriggerClosed"; }, never, never, true, never>;
+}
+
+declare class NgpDialog<T = unknown, R = unknown> implements OnDestroy {
+    private readonly config;
+    /** Access the dialog ref */
+    private readonly dialogRef;
+    /** The id of the dialog */
+    readonly id: _angular_core.InputSignal<string>;
+    /** The dialog role. */
+    readonly role: _angular_core.InputSignal<NgpDialogRole | undefined>;
+    /** Whether the dialog is a modal. */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The labelledby ids */
+    protected readonly labelledBy: _angular_core.WritableSignal<string[]>;
+    /** The describedby ids */
+    protected readonly describedBy: _angular_core.WritableSignal<string[]>;
+    /** The dialog state */
+    protected readonly state: ng_primitives_state.CreatedState<NgpDialog<T, R>>;
+    ngOnDestroy(): void;
+    /** Close the dialog. */
+    close(result?: R): void;
+    /** Stop click events from propagating to the overlay */
+    protected onClick(event: Event): void;
+    /** @internal register a labelledby id */
+    setLabelledBy(id: string): void;
+    /** @internal register a describedby id */
+    setDescribedBy(id: string): void;
+    /** @internal remove a labelledby id */
+    removeLabelledBy(id: string): void;
+    /** @internal remove a describedby id */
+    removeDescribedBy(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpDialog<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpDialog<any, any>, "[ngpDialog]", ["ngpDialog"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "role": { "alias": "ngpDialogRole"; "required": false; "isSignal": true; }; "modal": { "alias": "ngpDialogModal"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.NgpFocusTrap; inputs: {}; outputs: {}; }, { directive: typeof i1.NgpExitAnimation; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Provides the Dialog state.
+ */
+declare const provideDialogState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the Dialog state.
+ */
+declare const injectDialogState: <U = NgpDialog<unknown, unknown>>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpDialog, NgpDialogDescription, NgpDialogManager, NgpDialogOverlay, NgpDialogRef, NgpDialogTitle, NgpDialogTrigger, injectDialogRef, injectDialogState, provideDialogConfig, provideDialogState };
+export type { NgpDialogConfig };

package/fesm2022/ng-primitives-a11y.mjs

@@ -14,9 +14,9 @@ function activeDescendantManager(options) {
             ? -1
             : 1;
     });
-    const activeIndex = signal(0);
-    const activeItem = computed(() => sortedOptions()?.[activeIndex()]);
-    const disabled = computed(() => options.disabled?.() || options.items().every(item => item.disabled?.()));
+    const activeIndex = signal(0, ...(ngDevMode ? [{ debugName: "activeIndex" }] : []));
+    const activeItem = computed(() => sortedOptions()?.[activeIndex()], ...(ngDevMode ? [{ debugName: "activeItem" }] : []));
+    const disabled = computed(() => options.disabled?.() || options.items().every(item => item.disabled?.()), ...(ngDevMode ? [{ debugName: "disabled" }] : []));
     // any time the item list changes, check if the active index is still valid
     explicitEffect([sortedOptions], ([items]) => {
         if (activeIndex() >= items.length || activeIndex() < 0) {
@@ -35,7 +35,7 @@ function activeDescendantManager(options) {
             return undefined;
         }
         return item.id();
-    });
+    }, ...(ngDevMode ? [{ debugName: "activeDescendant" }] : []));
     /**
      * Activate an item in the active descendant group.
      * @param item The item to activate.
@@ -149,7 +149,7 @@ class NgpVisuallyHidden {
         /**
          * Whether the element is hidden.
          */
-        this.hidden = signal(true);
+        this.hidden = signal(true, ...(ngDevMode ? [{ debugName: "hidden" }] : []));
         this.style = computed(() => {
             if (!this.hidden()) {
                 return {};
@@ -170,7 +170,7 @@ class NgpVisuallyHidden {
                 '-moz-appearance': 'none',
                 'inset-inline-start': '0',
             };
-        });
+        }, ...(ngDevMode ? [{ debugName: "style" }] : []));
         this.state = visuallyHiddenState(this);
     }
     /**
@@ -181,10 +181,10 @@ class NgpVisuallyHidden {
         this.hidden.set(!visible);
         this.changeDetector.detectChanges();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: NgpVisuallyHidden, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.11", type: NgpVisuallyHidden, isStandalone: true, selector: "[ngpVisuallyHidden]", host: { properties: { "style": "style()" } }, providers: [provideVisuallyHiddenState()], exportAs: ["ngpVisuallyHidden"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NgpVisuallyHidden, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.9", type: NgpVisuallyHidden, isStandalone: true, selector: "[ngpVisuallyHidden]", host: { properties: { "style": "style()" } }, providers: [provideVisuallyHiddenState()], exportAs: ["ngpVisuallyHidden"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: NgpVisuallyHidden, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NgpVisuallyHidden, decorators: [{
             type: Directive,
             args: [{
                     selector: '[ngpVisuallyHidden]',