@qualcomm-ui/angular-core 1.0.2 → 1.0.3

package/common/index.d.ts

@@ -1,10 +1,84 @@
-export type * from "./boolean";
-export type * from "./ng-changes";
-export type * from "./template-content";
-export * from "./use-csr-check";
-export * from "./use-id";
-export * from "./use-is-destroyed";
-export * from "./use-is-mounted";
-export * from "./use-on-destroy";
-export * from "./use-ssr-check";
-//# sourceMappingURL=index.d.ts.map
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+import { Signal, TemplateRef } from '@angular/core';
+
+/**
+ * @custom boolean
+ */
+type CoercibleBoolean = Booleanish;
+
+type NgChanges<Component> = {
+    [Key in keyof Component]: Component[Key] extends Signal<infer T> ? {
+        currentValue: T;
+        firstChange: boolean;
+        isFirstChange(): boolean;
+        previousValue: T;
+    } : {
+        currentValue: Component[Key];
+        firstChange: boolean;
+        isFirstChange(): boolean;
+        previousValue: Component[Key];
+    };
+};
+type NgChangesAllProps<Component> = {
+    [Key in keyof Component]: Key;
+};
+
+/**
+ * An input type that can be a string or TemplateRef.
+ */
+type TemplateContent<T> = string | TemplateRef<T>;
+
+/**
+ * A utility function to determine whether the current rendering context is
+ * client-side.
+ *
+ * This hook internally relies on Angular's `PLATFORM_ID` to check the execution
+ * context and evaluates if the current platform is running on the client. It
+ * returns a boolean function that can be invoked to check the CSR status
+ * dynamically.
+ *
+ * @returns A function that returns true if the rendering platform is client-side, false otherwise.
+ */
+declare function useCsrCheck(): () => boolean;
+
+declare function useId(component: object, id: string | undefined | null): string;
+
+/**
+ * Creates a utility that provides a check for whether a component has been
+ * destroyed.
+ *
+ * @returns A single method for checking the destroy status of the component.
+ */
+declare function useIsDestroyed(): () => boolean;
+
+/**
+ * Creates a utility that provides a check for whether a component is still mounted.
+ *
+ * @returns A single method for checking the status of the component.
+ */
+declare function useIsMounted(): () => boolean;
+
+/**
+ * Creates a utility that provides component cleanup functionality
+ * using Angular's DestroyRef.
+ *
+ * @returns A single method for registering a cleanup callback.
+ */
+declare function useOnDestroy(): (callback: () => void) => void;
+
+/**
+ * A utility function to determine whether the current rendering context is
+ * server-side.
+ *
+ * This hook internally relies on Angular's `PLATFORM_ID` to check the execution
+ * context and evaluates if the current platform is running on the server. It
+ * returns a boolean function that can be invoked to check the SSR status
+ * dynamically.
+ *
+ * @returns A function that returns true if the rendering platform is server-side, false otherwise.
+ */
+declare function useSsrCheck(): () => boolean;
+
+export { useCsrCheck, useId, useIsDestroyed, useIsMounted, useOnDestroy, useSsrCheck };
+export type { CoercibleBoolean, NgChanges, NgChangesAllProps, TemplateContent };
+//# sourceMappingURL=index.d.ts.map

package/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,WAAW,CAAA;AAC9B,mBAAmB,cAAc,CAAA;AACjC,mBAAmB,oBAAoB,CAAA;AACvC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA;AACxB,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/common/boolean.ts","../../src/common/ng-changes.ts","../../src/common/template-content.ts","../../src/common/use-csr-check.ts","../../src/common/use-id.ts","../../src/common/use-is-destroyed.ts","../../src/common/use-is-mounted.ts","../../src/common/use-on-destroy.ts","../../src/common/use-ssr-check.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;AAKA;;AAEG;AACG;;ACCA;AACH;;;;;;AAQK;;;AAGA;AACD;;AAGD;AAAuC;;;ACpB7C;;AAEG;AACG;;ACFN;;;;;;;;;;AAUG;AACH;;ACZA;;ACAA;;;;;AAKG;AACH;;ACNA;;;;AAIG;AACH;;ACLA;;;;;AAKG;AACH;;ACLA;;;;;;;;;;AAUG;AACH;;;"}

package/dialog/index.d.ts

@@ -1,12 +1,300 @@
-export * from "./core-dialog-backdrop.directive";
-export * from "./core-dialog-body.directive";
-export * from "./core-dialog-close-trigger.directive";
-export * from "./core-dialog-content.directive";
-export * from "./core-dialog-description.directive";
-export * from "./core-dialog-footer.directive";
-export * from "./core-dialog-heading.directive";
-export * from "./core-dialog-positioner.directive";
-export * from "./core-dialog-root.directive";
-export * from "./core-dialog-trigger.directive";
-export * from "./dialog-context.service";
-//# sourceMappingURL=index.d.ts.map
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef, Provider } from '@angular/core';
+import * as _qualcomm_ui_utils_direction from '@qualcomm-ui/utils/direction';
+import { Direction } from '@qualcomm-ui/utils/direction';
+import * as _qualcomm_ui_core_dialog from '@qualcomm-ui/core/dialog';
+import { DialogApi, DialogApiProps } from '@qualcomm-ui/core/dialog';
+import { RenderStrategyContextService, PresenceContextService, CorePresenceDirective } from '@qualcomm-ui/angular-core/presence';
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { PresenceApiProps } from '@qualcomm-ui/core/presence';
+import { LayerDismissEvent } from '@qualcomm-ui/dom/dismissable';
+import { MaybeElement, FocusOutsideEvent, InteractOutsideEvent, PointerDownOutsideEvent } from '@qualcomm-ui/dom/interact-outside';
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+
+declare class CoreDialogBackdropDirective implements OnInit {
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly parentRenderStrategyContext: RenderStrategyContextService;
+    protected readonly presenceContext: PresenceContextService;
+    protected readonly dialogBackdropProps: _angular_core.Signal<{
+        "data-state": string | undefined;
+        hidden: boolean;
+        "data-part": "backdrop";
+        id: string;
+        "data-scope": "dialog";
+        dir?: _qualcomm_ui_utils_direction.Direction | undefined;
+    }>;
+    protected readonly id: _angular_core.Signal<string>;
+    private readonly injector;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly presenceRendererEffect: _angular_core.EffectRef;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogBackdropDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogBackdropDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreDialogBodyDirective implements OnInit {
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogBodyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogBodyDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreDialogCloseTriggerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogCloseTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogCloseTriggerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreDialogContentDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly presenceService: PresenceContextService;
+    readonly elementRef: ElementRef<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly presenceRendererEffect: _angular_core.EffectRef;
+    private readonly hostId;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogContentDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreDialogDescriptionDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogDescriptionDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreDialogFooterDirective implements OnInit {
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogFooterDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreDialogHeadingDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly onDestroy: (callback: () => void) => void;
+    private readonly hostId;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogHeadingDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogHeadingDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreDialogPositionerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly onDestroy: (callback: () => void) => void;
+    private readonly hostId;
+    presenceRendererEffect: _angular_core.EffectRef;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogPositionerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogPositionerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DialogContextService extends BaseApiContextService<DialogApi> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogContextService>;
+}
+declare const DIALOG_CONTEXT: _angular_core.InjectionToken<() => DialogApi>;
+declare const useDialogContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => DialogApi) | null : () => DialogApi;
+
+declare function provideDialogContext(): Provider[];
+
+declare class CoreDialogRootDirective extends CorePresenceDirective implements SignalifyInput<Omit<DialogApiProps & PresenceApiProps, "aria-label">>, OnInit {
+    /**
+     * Human-readable label for the dialog, used when the dialog title is not rendered
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether to close the dialog when the escape key is pressed
+     *
+     * @default true
+     */
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether to close the dialog when the outside is clicked
+     *
+     * @default true
+     */
+    readonly closeOnInteractOutside: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The initial open state of the dialog when rendered.
+     * Use when you don't need to control the open state of the dialog.
+     */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The document's text/writing direction.
+     *
+     * @default "ltr"
+     */
+    readonly dir: _angular_core.InputSignal<Direction | undefined>;
+    /**
+     * Element to receive focus when the dialog is closed
+     */
+    readonly finalFocusEl: _angular_core.InputSignal<(() => MaybeElement) | undefined>;
+    /**
+     * A root node to correctly resolve the Document in custom environments. i.e.,
+     * Iframes, Electron.
+     */
+    readonly getRootNode: _angular_core.InputSignal<(() => ShadowRoot | Document | Node) | undefined>;
+    /**
+     * Element to receive focus when the dialog is opened
+     */
+    readonly initialFocusEl: _angular_core.InputSignal<(() => MaybeElement) | undefined>;
+    /**
+     * Whether to prevent pointer interaction outside the element and hide all content
+     * below it
+     *
+     * @default true
+     */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The controlled open state of the dialog
+     */
+    readonly open: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * The persistent elements that:
+     * - should not have pointer-events disabled
+     * - should not trigger the dismiss event
+     */
+    readonly persistentElements: _angular_core.InputSignal<(() => Element | null)[] | undefined>;
+    /**
+     * Whether to prevent scrolling behind the dialog when it's opened
+     *
+     * @default true
+     */
+    readonly preventScroll: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether to restore focus to the element that had focus before the dialog was
+     * opened
+     *
+     * @default true
+     */
+    readonly restoreFocus: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The dialog's role
+     *
+     * @default 'dialog'
+     */
+    readonly role: _angular_core.InputSignal<"dialog" | "alertdialog" | undefined>;
+    /**
+     * Whether to trap focus inside the dialog when it's opened
+     *
+     * @default true
+     */
+    readonly trapFocus: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Function called when the escape key is pressed
+     */
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    /**
+     * Function called when the focus is moved outside the component
+     */
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusOutsideEvent>;
+    /**
+     * Function called when an interaction happens outside the component
+     */
+    readonly interactOutside: _angular_core.OutputEmitterRef<InteractOutsideEvent>;
+    /**
+     * Fired when the dialog opens or closes.
+     */
+    readonly openChanged: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Function called when the pointer is pressed down outside the component
+     */
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerDownOutsideEvent>;
+    /**
+     * Function called when this layer is closed due to a parent layer being closed
+     */
+    readonly requestDismissed: _angular_core.OutputEmitterRef<LayerDismissEvent>;
+    protected readonly dialogService: DialogContextService;
+    protected readonly presenceService: PresenceContextService;
+    protected readonly renderStrategyContext: RenderStrategyContextService;
+    protected readonly isMounted: () => boolean;
+    private readonly injector;
+    private document;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogRootDirective, never, never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnInteractOutside": { "alias": "closeOnInteractOutside"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "finalFocusEl": { "alias": "finalFocusEl"; "required": false; "isSignal": true; }; "getRootNode": { "alias": "getRootNode"; "required": false; "isSignal": true; }; "initialFocusEl": { "alias": "initialFocusEl"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "persistentElements": { "alias": "persistentElements"; "required": false; "isSignal": true; }; "preventScroll": { "alias": "preventScroll"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "trapFocus": { "alias": "trapFocus"; "required": false; "isSignal": true; }; }, { "escapeKeyDown": "escapeKeyDown"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openChanged": "openChanged"; "pointerDownOutside": "pointerDownOutside"; "requestDismissed": "requestDismissed"; }, never, never, true, never>;
+}
+
+declare class CoreDialogTriggerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly dialogContext: () => _qualcomm_ui_core_dialog.DialogApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreDialogTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreDialogTriggerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CoreDialogBackdropDirective, CoreDialogBodyDirective, CoreDialogCloseTriggerDirective, CoreDialogContentDirective, CoreDialogDescriptionDirective, CoreDialogFooterDirective, CoreDialogHeadingDirective, CoreDialogPositionerDirective, CoreDialogRootDirective, CoreDialogTriggerDirective, DIALOG_CONTEXT, DialogContextService, provideDialogContext, useDialogContext };
+//# sourceMappingURL=index.d.ts.map

package/dialog/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialog/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAA;AAChD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,uCAAuC,CAAA;AACrD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,qCAAqC,CAAA;AACnD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,0BAA0B,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/dialog/core-dialog-backdrop.directive.ts","../../src/dialog/core-dialog-body.directive.ts","../../src/dialog/core-dialog-close-trigger.directive.ts","../../src/dialog/core-dialog-content.directive.ts","../../src/dialog/core-dialog-description.directive.ts","../../src/dialog/core-dialog-footer.directive.ts","../../src/dialog/core-dialog-heading.directive.ts","../../src/dialog/core-dialog-positioner.directive.ts","../../src/dialog/dialog-context.service.ts","../../src/dialog/core-dialog-root.directive.ts","../../src/dialog/core-dialog-trigger.directive.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null],"names":[],"mappings":"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"}

package/dom/index.d.ts

@@ -1,8 +1,162 @@
-export * from "./clipboard.service";
-export * from "./context-id-signal";
-export * from "./descendants-manager.service";
-export * from "./element-id-signal";
-export * from "./id.service";
-export * from "./portal-config.service";
-export * from "./tokens";
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { OnDestroy, Signal, WritableSignal, CreateSignalOptions, DestroyRef, InjectionToken } from '@angular/core';
+import { LucideIcon } from '@qualcomm-ui/angular-core/lucide';
+import { DescendantsManager, DescendantOptions } from '@qualcomm-ui/utils/descendants';
+
+/**
+ * A simple helper service for copying text to the user's clipboard. SSR-safe,
+ * debounce support, and optional icon support.
+ */
+declare class ClipboardService implements OnDestroy {
+    get copied(): Signal<boolean>;
+    private readonly _copied;
+    readonly icon: Signal<LucideIcon>;
+    private copyTimeout;
+    private navigator;
+    private platformId;
+    ngOnDestroy(): void;
+    copy(text: string, timeout?: number): Promise<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
+}
+
+type ContextIdSignal = WritableSignal<string> & {
+    /**
+     * Retrieves the id string, or undefined if it is empty. When you bind `undefined`
+     * to an attribute in Angular, the attribute is removed from the DOM element.
+     *
+     * @example
+     *
+     * ```ts
+     * @Component({
+     *   template: `
+     *     <div id="1" [attr.aria-labelledby]="emptyId"></div>
+     *     <div id="2" [attr.aria-labelledby]="undefinedId"></div>
+     *   `
+     * })
+     * class Component {
+     *   emptyId = ""
+     *   undefinedId = undefined
+     * }
+     *```
+     *
+     *```html
+     * <!-- resulting DOM elements: -->
+     * <!-- invalid DOM element: aria-labelledby must be set if defined -->
+     * <div id="1" aria-labelledby></div>
+     *
+     * <!-- valid DOM element -->
+     * <div id="2"></div>
+     *```
+     */
+    asAttribute(): string | undefined;
+    set(value: string, onDestroy?: (callback: () => void) => void): void;
+};
+/**
+ * A simple wrapper around a signal for tracking an element's id in a shared
+ * service. This signal resets the value when its element's reference is destroyed.
+ *
+ * @param initialValue
+ * @param options
+ */
+declare function contextIdSignal(initialValue?: string, options?: CreateSignalOptions<string | undefined>): ContextIdSignal;
+
+declare class DescendantsManagerService<T extends HTMLElement, K extends Record<string, any> = object> extends DescendantsManager<T, K> {
+    get subscribe(): i0.Signal<number>;
+    private readonly _subscribe;
+    emit(): void;
+    register(nodeOrOptions: T | null | DescendantOptions<K>): void;
+    unregister(node: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DescendantsManagerService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DescendantsManagerService<any, any>>;
+}
+
+type ElementIdSignal = WritableSignal<string> & {
+    /**
+     * Retrieves the id string, or undefined if it is empty. When you bind `undefined`
+     * to an attribute in Angular, the attribute is removed from the DOM element.
+     *
+     * @example
+     *
+     * ```ts
+     * @Component({
+     *   template: `
+     *     <div id="1" [attr.aria-labelledby]="emptyId"></div>
+     *     <div id="2" [attr.aria-labelledby]="undefinedId"></div>
+     *   `
+     * })
+     * class Component {
+     *   emptyId = ""
+     *   undefinedId = undefined
+     * }
+     *```
+     *
+     *```html
+     * <!-- resulting DOM elements: -->
+     * <!-- invalid DOM element: aria-labelledby must be set if defined -->
+     * <div id="1" aria-labelledby></div>
+     *
+     * <!-- valid DOM element -->
+     * <div id="2"></div>
+     *```
+     */
+    asAttribute(): string | undefined;
+    set(value: string, destroyRef: DestroyRef): void;
+};
+/**
+ * A simple wrapper around a signal for tracking an element's id in a shared
+ * service. This signal resets the value when its element's reference is destroyed.
+ *
+ * @param initialValue
+ * @param options
+ */
+declare function elementIdSignal(initialValue?: string, options?: CreateSignalOptions<string | undefined>): ElementIdSignal;
+
+/**
+ * Simple service that can persist IDs across from SSR to CSR.
+ */
+declare class IdService {
+    private ids;
+    useId(componentName: string, idProp: string | undefined | null, idAttr: string | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdService>;
+}
+
+declare class PortalConfigService {
+    private _portalNodeId;
+    get portalNodeId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PortalConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PortalConfigService>;
+}
+
+declare const CACHES: InjectionToken<CacheStorage>;
+
+/**
+ * Use Window['CSS'], this is a workaround to support Angular 6+
+ */
+interface Css {
+    escape(ident: string): string;
+    supports(property: string, value: string): boolean;
+    supports(conditionText: string): boolean;
+}
+declare const CSS: InjectionToken<Css>;
+
+declare const LOCAL_STORAGE: InjectionToken<Storage>;
+
+declare const LOCATION: InjectionToken<Location>;
+
+declare const MEDIA_DEVICES: InjectionToken<MediaDevices>;
+
+declare const NAVIGATOR: InjectionToken<Navigator>;
+
+declare const PERFORMANCE: InjectionToken<Performance>;
+
+declare const SCREEN: InjectionToken<Screen>;
+
+declare const USER_AGENT: InjectionToken<string>;
+
+declare const WINDOW: InjectionToken<Window>;
+
+export { CACHES, CSS, ClipboardService, DescendantsManagerService, IdService, LOCAL_STORAGE, LOCATION, MEDIA_DEVICES, NAVIGATOR, PERFORMANCE, PortalConfigService, SCREEN, USER_AGENT, WINDOW, contextIdSignal, elementIdSignal };
+export type { ContextIdSignal, ElementIdSignal };
+//# sourceMappingURL=index.d.ts.map

package/dom/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dom/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,qBAAqB,CAAA;AACnC,cAAc,cAAc,CAAA;AAC5B,cAAc,yBAAyB,CAAA;AACvC,cAAc,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/dom/clipboard.service.ts","../../src/dom/context-id-signal.ts","../../src/dom/descendants-manager.service.ts","../../src/dom/element-id-signal.ts","../../src/dom/id.service.ts","../../src/dom/portal-config.service.ts","../../src/dom/tokens/caches.ts","../../src/dom/tokens/css.ts","../../src/dom/tokens/local-storage.ts","../../src/dom/tokens/location.ts","../../src/dom/tokens/media-devices.ts","../../src/dom/tokens/navigator.ts","../../src/dom/tokens/performance.ts","../../src/dom/tokens/screen.ts","../../src/dom/tokens/user-agent.ts","../../src/dom/tokens/window.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;AAmBA;;;AAGG;AACH;AAEE;AAGA;AAEA;;;;;AAaM;;;AAaP;;;AC9CC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACH;AAEA;;AAGF;;;;;;AAMG;AACH;;ACxCA;AAME;AAIA;;;;;;AAeD;;;ACxBC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACH;;;AAKF;;;;;;AAMG;AACH;;AC9CA;;AAEG;AACH;;AAIE;;;AAoBD;;AC3BD;;AAIE;;;AAGD;;ACLD;;ACAA;;AAEG;AACH;AACE;;AAEA;AACD;AAED;;ACTA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACDA;;;"}

package/events/index.d.ts

@@ -1,3 +1,40 @@
-export * from "./listener.service";
-export * from "./use-copy-to-clipboard";
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+type ListenerTrigger = "hover" | "focus" | "click" | "manual";
+type ListenerTriggerOn = "focus" | "mouse-enter";
+type ListenerTriggerOff = "blur" | "mouse-leave";
+type ListenerTriggerToggle = "click";
+interface ListenerConfig {
+    callbackOff?: (event: any, reason: ListenerTriggerOff) => void;
+    callbackOn?: (event: any, reason: ListenerTriggerOn) => void;
+    callbackToggle?: (event: any, reason: ListenerTriggerToggle) => void;
+    hostElement: ElementRef;
+    trigger?: ListenerTrigger | ListenerTrigger[];
+}
+declare class ListenerService {
+    private listeners;
+    private rendererListeners;
+    private renderer;
+    private document;
+    setDocumentListener<T extends Event>(eventName: string, callback: (event: T) => void): void;
+    setListener<T extends Event>(el: HTMLElement | Document | Window, eventName: string, callback: (event: T) => void): void;
+    clearDomListeners(): void;
+    setListeners({ callbackOff, callbackOn, callbackToggle, hostElement, trigger, }: ListenerConfig): void;
+    clearListeners(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListenerService>;
+}
+
+interface UseCopyToClipboardProps {
+    valueOrFn: (() => string) | string;
+}
+interface UseCopyToClipboard {
+    copyToClipboard: () => void;
+    isCopied: () => boolean;
+}
+declare function useCopyToClipboard(props: UseCopyToClipboardProps): UseCopyToClipboard;
+
+export { ListenerService, useCopyToClipboard };
+export type { ListenerConfig, ListenerTrigger, ListenerTriggerOff, ListenerTriggerOn, ListenerTriggerToggle, UseCopyToClipboard, UseCopyToClipboardProps };
+//# sourceMappingURL=index.d.ts.map

package/events/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/events/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/events/listener.service.ts","../../src/events/use-copy-to-clipboard.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;AAMM;;;AAIA;;AAGJ;AACA;AACA;;AAEA;AACD;AAED;;;;;AAQE;;;AAqBA;AA+DA;;;AAUD;;;AClHC;AACD;;;;AAKA;AAED;;;"}