@qualcomm-ui/angular-core 1.0.2 → 1.0.3

package/inline-notification/index.d.ts

@@ -1,8 +1,139 @@
-export * from "./core-inline-notification-action.directive";
-export * from "./core-inline-notification-close-trigger.directive";
-export * from "./core-inline-notification-description.directive";
-export * from "./core-inline-notification-icon.directive";
-export * from "./core-inline-notification-label.directive";
-export * from "./core-inline-notification-root.directive";
-export * from "./inline-notification-context.service";
-//# sourceMappingURL=index.d.ts.map
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+import * as _qualcomm_ui_core_inline_notification from '@qualcomm-ui/core/inline-notification';
+import { InlineNotificationApi, InlineNotificationApiProps } from '@qualcomm-ui/core/inline-notification';
+import * as i0 from '@angular/core';
+import { OnInit, Injector } from '@angular/core';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { Direction } from '@qualcomm-ui/utils/direction';
+
+declare class CoreInlineNotificationActionDirective implements OnInit {
+    protected readonly inlineNotificationContext: () => _qualcomm_ui_core_inline_notification.InlineNotificationApi;
+    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: i0.ɵɵFactoryDeclaration<CoreInlineNotificationActionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreInlineNotificationActionDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreInlineNotificationCloseTriggerDirective 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: i0.InputSignal<string | undefined>;
+    protected readonly inlineNotificationContext: () => _qualcomm_ui_core_inline_notification.InlineNotificationApi;
+    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: i0.ɵɵFactoryDeclaration<CoreInlineNotificationCloseTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreInlineNotificationCloseTriggerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreInlineNotificationDescriptionDirective 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: i0.InputSignal<string | undefined>;
+    protected readonly inlineNotificationContext: () => _qualcomm_ui_core_inline_notification.InlineNotificationApi;
+    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: i0.ɵɵFactoryDeclaration<CoreInlineNotificationDescriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreInlineNotificationDescriptionDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreInlineNotificationIconDirective implements OnInit {
+    protected readonly inlineNotificationContext: () => _qualcomm_ui_core_inline_notification.InlineNotificationApi;
+    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: i0.ɵɵFactoryDeclaration<CoreInlineNotificationIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreInlineNotificationIconDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreInlineNotificationLabelDirective 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: i0.InputSignal<string | undefined>;
+    protected readonly inlineNotificationContext: () => _qualcomm_ui_core_inline_notification.InlineNotificationApi;
+    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: i0.ɵɵFactoryDeclaration<CoreInlineNotificationLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreInlineNotificationLabelDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InlineNotificationContextService extends BaseApiContextService<InlineNotificationApi> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineNotificationContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InlineNotificationContextService>;
+}
+declare const INLINE_NOTIFICATION_CONTEXT: i0.InjectionToken<() => InlineNotificationApi>;
+declare const useInlineNotificationContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => InlineNotificationApi) | null : () => InlineNotificationApi;
+declare const provideInlineNotificationContext: () => i0.Provider[];
+
+declare class CoreInlineNotificationRootDirective implements SignalifyInput<InlineNotificationApiProps>, OnInit {
+    /**
+     * The document's text/writing direction.
+     *
+     * @default "ltr"
+     */
+    readonly dir: i0.InputSignal<Direction | undefined>;
+    /**
+     * A root node to correctly resolve the Document in custom environments. i.e.,
+     * Iframes, Electron.
+     */
+    readonly getRootNode: i0.InputSignal<(() => ShadowRoot | Document | Node) | undefined>;
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    /**
+     * The WAI-ARIA {@link https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Roles role} of the notification.
+     * @option `'alert'`: Use this role when the notification is an alert that requires the user's immediate attention, like for errors or urgent information.
+     * @option `'status'`: Use this role when the notification is a status message that doesn't require the user's immediate attention, like for success or informational messages.
+     *
+     * @default 'status'
+     */
+    readonly role: i0.InputSignal<"alert" | "status" | undefined>;
+    /**
+     * Function invoked when the notification is dismissed
+     */
+    readonly dismissed: i0.OutputEmitterRef<void>;
+    protected readonly inlineNotificationService: InlineNotificationContextService;
+    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 injector: Injector;
+    protected readonly isMounted: () => boolean;
+    private document;
+    private readonly hostId;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreInlineNotificationRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreInlineNotificationRootDirective, never, never, { "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "getRootNode": { "alias": "getRootNode"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, never, true, never>;
+}
+
+export { CoreInlineNotificationActionDirective, CoreInlineNotificationCloseTriggerDirective, CoreInlineNotificationDescriptionDirective, CoreInlineNotificationIconDirective, CoreInlineNotificationLabelDirective, CoreInlineNotificationRootDirective, INLINE_NOTIFICATION_CONTEXT, InlineNotificationContextService, provideInlineNotificationContext, useInlineNotificationContext };
+//# sourceMappingURL=index.d.ts.map

package/inline-notification/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/inline-notification/index.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAA;AAC3D,cAAc,oDAAoD,CAAA;AAClE,cAAc,kDAAkD,CAAA;AAChE,cAAc,2CAA2C,CAAA;AACzD,cAAc,4CAA4C,CAAA;AAC1D,cAAc,2CAA2C,CAAA;AACzD,cAAc,uCAAuC,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/inline-notification/core-inline-notification-action.directive.ts","../../src/inline-notification/core-inline-notification-close-trigger.directive.ts","../../src/inline-notification/core-inline-notification-description.directive.ts","../../src/inline-notification/core-inline-notification-icon.directive.ts","../../src/inline-notification/core-inline-notification-label.directive.ts","../../src/inline-notification/inline-notification-context.service.ts","../../src/inline-notification/core-inline-notification-root.directive.ts"],"sourcesContent":[null,null,null,null,null,null,null],"names":["_angular_core"],"mappings":";;;;;;;;;AASA,cAAA,qCAAA,YAAA,MAAA;AAEE,wDAA4C,qCAAA,CAAA,qBAAA;+CAEZ,iCAAA,CAAA,mBAAA;;;AAE9B;;;;AAKH;;ACVD,cAAA,2CAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,wDAA4C,qCAAA,CAAA,qBAAA;+CAEZ,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACxBD,cAAA,0CAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,wDAA4C,qCAAA,CAAA,qBAAA;+CAEZ,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACzBD,cAAA,mCAAA,YAAA,MAAA;AAEE,wDAA4C,qCAAA,CAAA,qBAAA;+CAEZ,iCAAA,CAAA,mBAAA;;;AAE9B;;;;AAKH;;ACVD,cAAA,oCAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,wDAA4C,qCAAA,CAAA,qBAAA;+CAEZ,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACtBD,cAAA,gCAAA,SAAA,qBAAA,CAAA,qBAAA;;;AACqG;AAErG,cAAA,2BAAA,EAC6BA,EAAA,CAAA,cAAA,OAAA,qBAAA;AAAA,cAC3B,wEAA4B,iCAAA,CAAA,cAAA,0DAAA,qBAAA,iBAAA,qBAAA;AAAA,cAC5B;;ACiBF,cAAA,mCAAA,YAAA,cAAA,CAAA,0BAAA,GAAA,MAAA;AAIE;;;;AAIG;kBACSA,EAAA,CAAA,WAAA,CAAA,SAAA;AAEZ;;;AAGG;0BACiBA,EAAA,CAAA,WAAA,QAAA,UAAA,GAAA,QAAA,GAAA,IAAA;AAIpB;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX;;;;;;AAMG;mBACUA,EAAA,CAAA,WAAA;AAEb;;AAEG;wBACeA,EAAA,CAAA,gBAAA;AAElB,kDAAA,gCAAA;+CAIgC,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA,iCAAA,QAAA;AAEA;;AAIA;;;;AAwBD;;;;"}

package/input/index.d.ts

@@ -1,4 +1,190 @@
-export * from "./abstract-input-form-control.directive";
-export * from "./abstract-list-collection-form-control.directive";
-export * from "./input-form-control-provider";
-//# sourceMappingURL=index.d.ts.map
+import * as _qualcomm_ui_angular_core_input from '@qualcomm-ui/angular-core/input';
+import * as _angular_core from '@angular/core';
+import { OnInit, Injector, Signal, WritableSignal, InjectionToken } from '@angular/core';
+import { ControlValueAccessor, FormControlStatus, AbstractControl, NgControl } from '@angular/forms';
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+import { CollectionItem, ListCollection } from '@qualcomm-ui/utils/collection';
+import { FormEventData } from '@qualcomm-ui/angular-core/forms';
+
+declare abstract class AbstractInputFormControlDirective implements ControlValueAccessor, OnInit {
+    /**
+     * The initial state of the input when rendered. Use when you don't
+     * need to control the checked state of the input. This property will be
+     * ignored if you opt into controlled state via form control bindings.
+     */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Controls whether the input is disabled in template-driven forms. When true,
+     * prevents user interaction and applies visual styling to indicate the disabled
+     * state.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Controls the visual error state of the input. When true, applies semantic error
+     * styling to indicate validation failure.
+     */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The name of the input field. Useful for form submission.
+     */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the input is read-only. When true, prevents user interaction while
+     * keeping the input focusable and visible.
+     */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Controls whether the input is required in template-driven forms. When
+     * true, the input must have a value for form validation to pass.
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    protected readonly value: _angular_core.WritableSignal<string>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly injector: Injector;
+    protected readonly formControlStatus: _angular_core.WritableSignal<FormControlStatus | undefined>;
+    protected readonly formSubmitted: _angular_core.WritableSignal<boolean>;
+    readonly formControlContext: _qualcomm_ui_angular_core_input.InputFormControlContext<string>;
+    /**
+     * If the component is bound to an Angular AbstractControl, its state wins.
+     * If not, fall back to the host attribute.
+     */
+    protected readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    readonly isRequired: _angular_core.WritableSignal<boolean | undefined>;
+    constructor();
+    ngOnInit(): void;
+    /** Convenience access to the underlying AbstractControl (can be null). */
+    get control(): AbstractControl | null;
+    /**
+     * Used to subscribe to form submit events.
+     */
+    private getParentForm;
+    writeValue(value: any): void;
+    protected onChange: (_value: any) => void;
+    registerOnChange(fn: (value: any) => void): void;
+    protected onTouched: () => void;
+    registerOnTouched(fn: () => void): void;
+    /**
+     * NgModel never calls setDisabledState, but ReactiveForms does. Everything else
+     * (writeValue, registerOnChange, registerOnTouched) is identical between Reactive
+     * and Template forms.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractInputFormControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractInputFormControlDirective, never, never, { "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class AbstractListCollectionFormControlDirective<T extends CollectionItem> implements ControlValueAccessor, OnInit {
+    /**
+     * The item collection
+     *
+     * @inheritDoc
+     */
+    readonly collection: _angular_core.InputSignal<ListCollection<T>>;
+    /**
+     * The initial state of the input when rendered. Use when you don't need to
+     * control the checked state of the input. This property will be ignored if you
+     * opt into controlled state via form control bindings.
+     *
+     * @inheritDoc
+     */
+    readonly defaultValue: _angular_core.InputSignal<T[] | undefined>;
+    /**
+     * Controls whether the input is disabled in template-driven forms. When true,
+     * prevents user interaction and applies visual styling to indicate the disabled
+     * state.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Controls the visual error state of the input. When true, applies semantic error
+     * styling to indicate validation failure.
+     */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The name of the input field. Useful for form submission.
+     */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the input is read-only. When true, prevents user interaction while
+     * keeping the input focusable and visible.
+     */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Controls whether the input is required in template-driven forms. When
+     * true, the input must have a value for form validation to pass.
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    protected readonly value: _angular_core.WritableSignal<T[]>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly injector: Injector;
+    protected readonly formControlStatus: _angular_core.WritableSignal<FormControlStatus | undefined>;
+    protected readonly formSubmitted: _angular_core.WritableSignal<boolean>;
+    readonly formControlContext: _qualcomm_ui_angular_core_input.InputFormControlContext<T[]>;
+    /**
+     * If the component is bound to an Angular AbstractControl, its state wins.
+     * If not, fall back to the host attribute.
+     */
+    protected readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    readonly isRequired: _angular_core.WritableSignal<boolean | undefined>;
+    constructor();
+    ngOnInit(): void;
+    /** Convenience access to the underlying AbstractControl (can be null). */
+    get control(): AbstractControl | null;
+    /**
+     * Used to subscribe to form submit events.
+     */
+    private getParentForm;
+    writeValue(value: any): void;
+    protected onChange: (_value: any) => void;
+    registerOnChange(fn: (value: any) => void): void;
+    protected onTouched: () => void;
+    registerOnTouched(fn: () => void): void;
+    /**
+     * NgModel never calls setDisabledState, but ReactiveForms does. Everything else
+     * (writeValue, registerOnChange, registerOnTouched) is identical between Reactive
+     * and Template forms.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractListCollectionFormControlDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractListCollectionFormControlDirective<any>, never, never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface InputFormControlContext<T> {
+    control?: NgControl["control"] | null;
+    /**
+     * Computed error message from the underlying control.
+     */
+    errorText: Signal<string | undefined | null>;
+    formEventData: WritableSignal<FormEventData<T | undefined> | null>;
+    /** `true` when used with reactive-forms (`formControl`, `formControlName`). */
+    isReactiveForm: () => boolean;
+    /** `true` when used with template-driven forms (`[(ngModel)]`, `ngModel`). */
+    isTemplateDrivenForm: () => boolean;
+    ngControl: NgControl | null;
+}
+type FormControlKnownErrors = Record<string, ((error: any) => string) | undefined>;
+/**
+ * Override the default error messages for known form control errors.
+ *
+ * The defaults are as follows:
+ * ```angular-html
+ * const defaultKnownErrors: FormControlKnownErrors = {
+ *   email: () => "Invalid email",
+ *   max: (err) => `Max: ${err.max}`,
+ *   maxLength: (err) => `Max length: ${err.maxLength}`,
+ *   min: (err) => `Min: ${err.min}`,
+ *   minLength: (err) => `Min length: ${err.requiredLength}`,
+ *   pattern: () => "Invalid format",
+ *   required: () => "This field is required",
+ *   requiredTrue: () => "This field is required",
+ * }
+ * ```
+ */
+declare const FORM_CONTROL_ERROR_MESSAGE_PROVIDER: InjectionToken<Partial<FormControlKnownErrors>>;
+declare const INPUT_FORM_CONTROL_CONTEXT: InjectionToken<InputFormControlContext<any>>;
+declare function initInputFormControl<T = string>(): InputFormControlContext<T>;
+
+export { AbstractInputFormControlDirective, AbstractListCollectionFormControlDirective, FORM_CONTROL_ERROR_MESSAGE_PROVIDER, INPUT_FORM_CONTROL_CONTEXT, initInputFormControl };
+export type { FormControlKnownErrors, InputFormControlContext };
+//# sourceMappingURL=index.d.ts.map

package/input/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/input/index.ts"],"names":[],"mappings":"AAAA,cAAc,yCAAyC,CAAA;AACvD,cAAc,mDAAmD,CAAA;AACjE,cAAc,+BAA+B,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/input/abstract-input-form-control.directive.ts","../../src/input/abstract-list-collection-form-control.directive.ts","../../src/input/input-form-control-provider.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;;;;;AAqCA;AAIE;;;;AAIG;;AAGH;;;;AAIG;;AAKH;;;AAGG;;AAKH;;AAEG;;AAGH;;;AAGG;;AAKH;;;AAGG;;AAMH;AACA;AACA;AACA;AAGA;;AAIA;;;AAGG;AACH;;;;;;AAoJA;AAIA;;AAEG;AACH;AA2BA;AAKA;;;AAUA;AAIA;;;;AAIG;AACH;;;AAGD;;AC7QD;AAME;;;;AAIG;;AAGH;;;;;;AAMG;;AAGH;;;;AAIG;;AAKH;;;AAGG;;AAKH;;AAEG;;AAGH;;;AAGG;;AAKH;;;AAGG;;AAMH;AACA;AACA;AACA;AAGA;;AAIA;;;AAGG;AACH;;;;;;AAsKA;AAIA;;AAEG;AACH;AA2BA;AAKA;;;AAUA;AAIA;;;;AAIG;AACH;;;AAGD;;ACxUK;;AAEJ;;AAEG;;AAEH;;;;;AAKA;AACD;;AAkBD;;;;;;;;;;;;;;;;AAgBG;AACH;AAIA;AAIA;;;"}

package/locale/index.d.ts

@@ -1,3 +1,24 @@
-export * from "./locale-context.service";
-export * from "./use-filter";
-//# sourceMappingURL=index.d.ts.map
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { Locale } from '@qualcomm-ui/utils/direction';
+import { FilterOptions, FilterReturn } from '@qualcomm-ui/utils/i18n';
+
+declare class LocaleContextService extends BaseApiContextService<Locale> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleContextService>;
+}
+declare const LOCALE_CONTEXT: i0.InjectionToken<() => Locale>;
+declare const useLocaleContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => Locale) | null : () => Locale;
+declare const provideLocaleContext: () => i0.Provider[];
+
+interface UseFilterProps extends FilterOptions {
+}
+interface UseFilterReturn extends FilterReturn {
+}
+declare function useFilter(props: UseFilterProps): Signal<UseFilterReturn>;
+
+export { LOCALE_CONTEXT, LocaleContextService, provideLocaleContext, useFilter, useLocaleContext };
+export type { UseFilterProps, UseFilterReturn };
+//# sourceMappingURL=index.d.ts.map

package/locale/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/locale/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/locale/locale-context.service.ts","../../src/locale/use-filter.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;;;AAYA;;;AAC0E;AAE1E;AACgB;AACE;;ACJZ;AAAkD;AAClD;AAAkD;AAExD;;;"}

package/lorem-ipsum/index.d.ts

@@ -1,2 +1,47 @@
-export * from "./lorem-ipsum.directive";
-//# sourceMappingURL=index.d.ts.map
+import * as _angular_core from '@angular/core';
+import { NumberInput, Booleanish } from '@qualcomm-ui/utils/coercion';
+import { LoremIpsumOptions } from '@qualcomm-ui/utils/lorem-ipsum';
+
+declare class LoremIpsumDirective {
+    /**
+     * Average number of sentences created for each paragraph (standard deviation is
+     * fixed ±25%)
+     *
+     * @default 5
+     */
+    readonly avgSentencesPerParagraph: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Average number of words created for each sentence (standard deviation is fixed
+     * ±25%)
+     *
+     * @default 8
+     */
+    readonly avgWordsPerSentence: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * @default 1
+     */
+    readonly numParagraphs: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * If `false`, always generates the same paragraphs in order.
+     *
+     * @default false
+     */
+    readonly random: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Seed for deterministic random generation. If not provided, uses Math.random()
+     */
+    readonly seed: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Start with 'Lorem ipsum odor amet...' to first sentence of first paragraph
+     *
+     * @default true
+     */
+    readonly startWithLoremIpsum: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    readonly loremIpsumOptions: _angular_core.Signal<LoremIpsumOptions>;
+    readonly paragraphs: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoremIpsumDirective, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoremIpsumDirective, "[q-lorem-ipsum]", never, { "avgSentencesPerParagraph": { "alias": "avgSentencesPerParagraph"; "required": false; "isSignal": true; }; "avgWordsPerSentence": { "alias": "avgWordsPerSentence"; "required": false; "isSignal": true; }; "numParagraphs": { "alias": "numParagraphs"; "required": false; "isSignal": true; }; "random": { "alias": "random"; "required": false; "isSignal": true; }; "seed": { "alias": "seed"; "required": false; "isSignal": true; }; "startWithLoremIpsum": { "alias": "startWithLoremIpsum"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { LoremIpsumDirective };
+//# sourceMappingURL=index.d.ts.map

package/lorem-ipsum/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lorem-ipsum/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/lorem-ipsum/lorem-ipsum.directive.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAYA,cAAA,mBAAA;AASE;;;;;AAKG;uCAC8B,aAAA,CAAA,wBAAA,qBAAA,WAAA;AAOjC;;;;;AAKG;kCACyB,aAAA,CAAA,wBAAA,qBAAA,WAAA;AAO5B;;AAEG;4BACmB,aAAA,CAAA,wBAAA,qBAAA,WAAA;AAItB;;;;AAIG;qBACY,aAAA,CAAA,wBAAA,sBAAA,UAAA;AAIf;;AAEG;mBACU,aAAA,CAAA,wBAAA,qBAAA,WAAA;AAIb;;;;AAIG;kCACyB,aAAA,CAAA,wBAAA,sBAAA,UAAA;gCAOF,aAAA,CAAA,MAAA,CAAA,iBAAA;yBAWP,aAAA,CAAA,MAAA;;;AACpB;;;;"}

package/lucide/index.d.ts

@@ -1,3 +1,53 @@
-export * from "./lucide.types";
-export * from "./provide-icons";
-//# sourceMappingURL=index.d.ts.map
+import { InjectionToken } from '@angular/core';
+
+type HtmlAttributes = {
+    [key: string]: string | number;
+};
+type LucideIconNode = readonly [string, HtmlAttributes];
+type LucideIconData = readonly LucideIconNode[];
+type SvgAttributes = {
+    [key: string]: string | number;
+};
+type LucideIconArrayData = readonly [string, SvgAttributes];
+type LucideIconCompat = readonly [
+    string,
+    SvgAttributes,
+    LucideIconNode[]?
+];
+type LucideIconPart = LucideIconNode;
+type LucideIcon = LucideIconData;
+/**
+ * The imported LucideIcon or a string. The string form of the icon works with the
+ * provider approach:
+ *
+ * @example
+ * ```ts
+ * import {IconDirective} from '@qualcomm-ui/angular/icon'
+ * import {provideIcons} from '@qualcomm-ui/angular-core/lucide'
+ * import {Search} from 'lucide-angular'
+ * ```
+ *
+ * @Component({
+ *   imports: [IconDirective],
+ *   providers: [provideIcons({Search})],
+ *   template: `
+ *     <svg qIcon="Search"></svg>
+ *   `
+ * })
+ * class ExampleComponent {}
+ * ```
+ */
+type LucideIconOrString = LucideIcon | string;
+
+type LucideIconProviderValue = Record<string, LucideIcon>;
+declare const LUCIDE_ICONS: InjectionToken<LucideIconProviderValue>;
+declare function provideIcons(icons: Record<string, LucideIcon>): {
+    provide: InjectionToken<LucideIconProviderValue>;
+    useFactory: () => Record<string, readonly (readonly [string, {
+        [key: string]: string | number;
+    }])[]>;
+};
+
+export { LUCIDE_ICONS, provideIcons };
+export type { LucideIcon, LucideIconArrayData, LucideIconCompat, LucideIconOrString, LucideIconPart, LucideIconProviderValue };
+//# sourceMappingURL=index.d.ts.map

package/lucide/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lucide/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/lucide/lucide.types.ts","../../src/lucide/provide-icons.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;AAGA;AACE;;AAEF;AACA;AAEA;AAAsB;;AAEhB;AAGA;;;AAGJ;;AAGI;AACA;AAEN;;;;;;;;;;;;;;;;;;;;AAoBG;;;ACpCG;AAEN;AAIA;;;;;AAcC;;;"}