@qualcomm-ui/angular-core 1.0.1 → 1.0.3

package/README.md

@@ -0,0 +1,9 @@
+# @qualcomm-ui/angular-core
+
+Design-agnostic Angular building blocks and utilities.
+
+This package provides low-level Angular primitives that power the QUI component library. For comprehensive documentation and usage guides, visit the [Angular documentation](https://angular-next.qui.qualcomm.com/).
+
+## License
+
+Licensed under the [BSD-3-Clause-Clear License](https://spdx.org/licenses/BSD-3-Clause-Clear.html).

package/accordion/index.d.ts

@@ -1,10 +1,160 @@
-export * from "./accordion-context.service";
-export * from "./accordion-item-context.service";
-export * from "./core-accordion-item-content.directive";
-export * from "./core-accordion-item-trigger-indicator.directive";
-export * from "./core-accordion-item-trigger-secondary.directive";
-export * from "./core-accordion-item-trigger-title.directive";
-export * from "./core-accordion-item-trigger.directive";
-export * from "./core-accordion-item.directive";
-export * from "./core-accordion-root.directive";
-//# 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 _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import * as _qualcomm_ui_core_accordion from '@qualcomm-ui/core/accordion';
+import { AccordionApi, AccordionItemApiProps, AccordionApiProps } from '@qualcomm-ui/core/accordion';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+import { Direction } from '@qualcomm-ui/utils/direction';
+
+declare class AccordionContextService extends BaseApiContextService<AccordionApi> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AccordionContextService>;
+}
+declare const ACCORDION_CONTEXT: _angular_core.InjectionToken<() => AccordionApi>;
+declare const useAccordionContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => AccordionApi) | null : () => AccordionApi;
+declare const provideAccordionContext: () => _angular_core.Provider[];
+
+declare class AccordionItemContextService extends BaseApiContextService<AccordionItemApiProps> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AccordionItemContextService>;
+}
+declare const ACCORDION_ITEM_CONTEXT: _angular_core.InjectionToken<() => AccordionItemApiProps>;
+declare const useAccordionItemContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => AccordionItemApiProps) | null : () => AccordionItemApiProps;
+declare const provideAccordionItemContext: () => _angular_core.Provider[];
+
+declare class CoreAccordionItemContentDirective 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 hostId: _angular_core.Signal<string>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected readonly accordionContext: () => _qualcomm_ui_core_accordion.AccordionApi;
+    protected readonly accordionItemContext: () => _qualcomm_ui_core_accordion.AccordionItemApiProps;
+    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<CoreAccordionItemContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreAccordionItemContentDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class CoreAccordionItemTriggerIndicatorDirective implements OnInit {
+    private readonly accordionContext;
+    private readonly accordionItemContext;
+    private readonly trackBindings;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreAccordionItemTriggerIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreAccordionItemTriggerIndicatorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class CoreAccordionItemTriggerSecondaryDirective implements OnInit {
+    private readonly accordionContext;
+    private readonly accordionItemContext;
+    private readonly trackBindings;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreAccordionItemTriggerSecondaryDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreAccordionItemTriggerSecondaryDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class CoreAccordionItemTriggerTitleDirective implements OnInit {
+    private readonly accordionContext;
+    private readonly accordionItemContext;
+    private readonly trackBindings;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreAccordionItemTriggerTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreAccordionItemTriggerTitleDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class CoreAccordionItemTriggerDirective 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>;
+    private readonly hostId;
+    private readonly accordionContext;
+    private readonly accordionItemContext;
+    private readonly trackBindings;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreAccordionItemTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreAccordionItemTriggerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class CoreAccordionItemDirective implements SignalifyInput<AccordionItemApiProps>, 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>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean | undefined>;
+    private readonly accordionItemContext;
+    private readonly hostId;
+    protected readonly accordionContext: () => _qualcomm_ui_core_accordion.AccordionApi;
+    protected readonly onDestroy: (callback: () => void) => void;
+    private readonly isDisabled;
+    private readonly trackBindings;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreAccordionItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreAccordionItemDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class CoreAccordionRootDirective implements SignalifyInput<AccordionApiProps>, OnInit {
+    /**
+     * HTML {@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>;
+    /**
+     * The document's text/writing direction.
+     */
+    readonly dir: _angular_core.InputSignal<Direction | undefined>;
+    /**
+     * Whether sections can be collapsed (in non-multiple mode).
+     */
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Initial value of the accordion.
+     */
+    readonly defaultValue: _angular_core.InputSignal<string[] | undefined>;
+    /**
+     * The disabled state of the accordion.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether multiple accordion items can be expanded at once.
+     */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Value(s) of the accordion's open item(s).
+     */
+    readonly value: _angular_core.InputSignal<string[] | undefined>;
+    /**
+     * Focus change callback.
+     */
+    readonly focusChanged: _angular_core.OutputEmitterRef<string | null>;
+    /**
+     * Value change callback.
+     */
+    readonly valueChanged: _angular_core.OutputEmitterRef<string[]>;
+    private readonly accordionContext;
+    private readonly injector;
+    private readonly onDestroy;
+    private readonly isMounted;
+    readonly hostId: _angular_core.Signal<string>;
+    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<CoreAccordionRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreAccordionRootDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "focusChanged": "focusChanged"; "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+export { ACCORDION_CONTEXT, ACCORDION_ITEM_CONTEXT, AccordionContextService, AccordionItemContextService, CoreAccordionItemContentDirective, CoreAccordionItemDirective, CoreAccordionItemTriggerDirective, CoreAccordionItemTriggerIndicatorDirective, CoreAccordionItemTriggerSecondaryDirective, CoreAccordionItemTriggerTitleDirective, CoreAccordionRootDirective, provideAccordionContext, provideAccordionItemContext, useAccordionContext, useAccordionItemContext };
+//# sourceMappingURL=index.d.ts.map

package/accordion/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/accordion/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kCAAkC,CAAA;AAChD,cAAc,yCAAyC,CAAA;AACvD,cAAc,mDAAmD,CAAA;AACjE,cAAc,mDAAmD,CAAA;AACjE,cAAc,+CAA+C,CAAA;AAC7D,cAAc,yCAAyC,CAAA;AACvD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iCAAiC,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/accordion/accordion-context.service.ts","../../src/accordion/accordion-item-context.service.ts","../../src/accordion/core-accordion-item-content.directive.ts","../../src/accordion/core-accordion-item-trigger-indicator.directive.ts","../../src/accordion/core-accordion-item-trigger-secondary.directive.ts","../../src/accordion/core-accordion-item-trigger-title.directive.ts","../../src/accordion/core-accordion-item-trigger.directive.ts","../../src/accordion/core-accordion-item.directive.ts","../../src/accordion/core-accordion-root.directive.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;AAWA,cAAA,uBAAA,SAAA,qBAAA,CAAA,YAAA;;;AACmF;AAEnF,cAAA,iBAAA,EAA+B,aAAA,CAAA,cAAA,OAAA,YAAA;AAAA,cAAE,+DAAmB,iCAAA,CAAA,cAAA,0DAAA,YAAA,iBAAA,YAAA;AAAA,cAAE;;ACHtD,cAAA,2BAAA,SAAA,qBAAA,CAAA,qBAAA;;;AACgG;AAEhG,cAAA,sBAAA,EACwB,aAAA,CAAA,cAAA,OAAA,qBAAA;AAAA,cACtB,mEAAuB,iCAAA,CAAA,cAAA,0DAAA,qBAAA,iBAAA,qBAAA;AAAA,cACvB;;ACNF,cAAA,iCAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQ,aAAA,CAAA,WAAA;AAEX,+BAAyB,aAAA,CAAA,MAAA;AAEzB;AAEA,+CAAmC,2BAAA,CAAA,YAAA;AACnC,mDAAuC,2BAAA,CAAA,qBAAA;+CAEP,iCAAA,CAAA,mBAAA;;;AAO/B;;;;AAKF;;AC5BD,uBAAA,0CAAA,YAAA,MAAA;AAIE;AACA;AAEA;;;;AAUD;;ACjBD,uBAAA,0CAAA,YAAA,MAAA;AAIE;AACA;AAEA;;;;AAUD;;ACjBD,uBAAA,sCAAA,YAAA,MAAA;AAEE;AACA;AAEA;;;;AAUD;;ACdD,uBAAA,iCAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQ,aAAA,CAAA,WAAA;AAEX;AAEA;AACA;AAEA;;;;AAWD;;ACfD,uBAAA,0BAAA,YAAA,cAAA,CAAA,qBAAA,GAAA,MAAA;AAIE;;;AAGG;iBACQ,aAAA,CAAA,WAAA;oBAEG,aAAA,CAAA,WAAA;uBAEG,aAAA,CAAA,WAAA;AAEjB;AAEA;AAEA,+CAAmC,2BAAA,CAAA,YAAA;AAEnC;AAEA;AAEA;;;;AAqBD;;AC7BD,uBAAA,0BAAA,YAAA,cAAA,CAAA,iBAAA,GAAA,MAAA;AAIE;;;AAGG;iBACQ,aAAA,CAAA,WAAA;AAEX;;AAEG;kBACS,aAAA,CAAA,WAAA,CAAA,SAAA;AAEZ;;AAEG;0BACiB,aAAA,CAAA,wBAAA,sBAAA,UAAA;AAIpB;;AAEG;2BACkB,aAAA,CAAA,WAAA;AAErB;;AAEG;uBACc,aAAA,CAAA,wBAAA,sBAAA,UAAA;AAIjB;;AAEG;uBACc,aAAA,CAAA,wBAAA,sBAAA,UAAA;AAIjB;;AAEG;oBACW,aAAA,CAAA,WAAA;AAEd;;AAEG;2BACkB,aAAA,CAAA,gBAAA;AAErB;;AAEG;2BACkB,aAAA,CAAA,gBAAA;AAErB;AAEA;AAEA;AAEA;qBAEe,aAAA,CAAA,MAAA;+CAEiB,iCAAA,CAAA,mBAAA;;;AAK/B;;;;AAiCF;;;;"}

package/attributes/index.d.ts

@@ -1,3 +1,19 @@
-export * from "./number-attributes";
-export * from "./pixel-attribute";
-//# sourceMappingURL=index.d.ts.map
+/**
+ * The `numberAttribute` transformer with a fallback to 0 if the input can't be
+ * parsed as a number.
+ */
+declare function numberAttributeOrZero(value: any): number;
+/**
+ * The `numberAttribute` transformer with a fallback to undefined if the input can't
+ * be parsed as a number.
+ */
+declare function numberAttributeOrUndefined(value: any): number | undefined;
+
+/**
+ * Coerces a string or number to a pixel value. Returns the value as-is if it
+ * doesn't match a number-ish format.
+ */
+declare function pixelAttribute(value: string | number): string;
+
+export { numberAttributeOrUndefined, numberAttributeOrZero, pixelAttribute };
+//# sourceMappingURL=index.d.ts.map

package/attributes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/attributes/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/attributes/number-attributes.ts","../../src/attributes/pixel-attribute.ts"],"sourcesContent":[null,null],"names":[],"mappings":"AAKA;;;AAGG;AACH,iBAAA,qBAAA;AAIA;;;AAGG;AACH,iBAAA,0BAAA;;ACdA;;;AAGG;AACH,iBAAA,cAAA;;;;"}

package/avatar/index.d.ts

@@ -1,6 +1,102 @@
-export * from "./avatar-context.service";
-export * from "./core-avatar-content.directive";
-export * from "./core-avatar-image.directive";
-export * from "./core-avatar-root.directive";
-export * from "./core-avatar-status.directive";
-//# 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 { OnInit, Injector } from '@angular/core';
+import { AvatarApi, AvatarApiProps } from '@qualcomm-ui/core/avatar';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { Direction } from '@qualcomm-ui/utils/direction';
+
+declare class AvatarContextService extends BaseApiContextService<AvatarApi> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AvatarContextService>;
+}
+declare const AVATAR_CONTEXT: i0.InjectionToken<() => AvatarApi>;
+declare const useAvatarContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => AvatarApi) | null : () => AvatarApi;
+declare const provideAvatarContext: () => i0.Provider[];
+
+declare class CoreAvatarContentDirective 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>;
+    private readonly hostId;
+    private readonly avatarContext;
+    private readonly onDestroy;
+    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<CoreAvatarContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreAvatarContentDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreAvatarImageDirective 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>;
+    private readonly hostId;
+    private readonly avatarContext;
+    private readonly onDestroy;
+    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<CoreAvatarImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreAvatarImageDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreAvatarRootDirective implements SignalifyInput<AvatarApiProps>, OnInit {
+    /**
+     * HTML {@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 document's text/writing direction.
+     */
+    readonly dir: i0.InputSignal<Direction | undefined>;
+    /**
+     * Function called when the avatar state is changed.
+     */
+    readonly stateChanged: i0.OutputEmitterRef<{
+        state: string | null;
+    }>;
+    protected readonly avatarContext: AvatarContextService;
+    protected readonly hostId: i0.Signal<string>;
+    protected readonly injector: Injector;
+    protected readonly isMounted: () => boolean;
+    protected readonly onDestroy: (callback: () => void) => void;
+    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<CoreAvatarRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreAvatarRootDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "stateChanged": "stateChanged"; }, never, never, true, never>;
+}
+
+declare class CoreAvatarStatusDirective 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>;
+    private readonly hostId;
+    private readonly avatarContext;
+    private readonly onDestroy;
+    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<CoreAvatarStatusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreAvatarStatusDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AVATAR_CONTEXT, AvatarContextService, CoreAvatarContentDirective, CoreAvatarImageDirective, CoreAvatarRootDirective, CoreAvatarStatusDirective, provideAvatarContext, useAvatarContext };
+//# sourceMappingURL=index.d.ts.map

package/avatar/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/avatar/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,gCAAgC,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/avatar/avatar-context.service.ts","../../src/avatar/core-avatar-content.directive.ts","../../src/avatar/core-avatar-image.directive.ts","../../src/avatar/core-avatar-root.directive.ts","../../src/avatar/core-avatar-status.directive.ts"],"sourcesContent":[null,null,null,null,null],"names":["_angular_core"],"mappings":";;;;;;;;AAWA,cAAA,oBAAA,SAAA,qBAAA,CAAA,SAAA;;;AAC6E;AAE7E,cAAA,cAAA,EAA4BA,EAAA,CAAA,cAAA,OAAA,SAAA;AAAA,cAAE,4DAAgB,iCAAA,CAAA,cAAA,0DAAA,SAAA,iBAAA,SAAA;AAAA,cAAE;;ACJhD,cAAA,0BAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX;AAEA;AAEA;+CAEgC,iCAAA,CAAA,mBAAA;;;AAK/B;;;;AAKF;;ACxBD,cAAA,wBAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX;AAEA;AAEA;+CAEgC,iCAAA,CAAA,mBAAA;;;AAK/B;;;;AAKF;;ACAD,cAAA,uBAAA,YAAA,cAAA,CAAA,cAAA,GAAA,MAAA;AAIE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX;;AAEG;kBACSA,EAAA,CAAA,WAAA,CAAA,SAAA;AAEZ;;AAEG;AACH,2BAAqBA,EAAA,CAAA,gBAAA;AAAkB;AAAiB;AAExD,sCAAA,oBAAA;AACA,+BAAyBA,EAAA,CAAA,MAAA;AACzB,iCAAA,QAAA;AACA;AACA;+CAEgC,iCAAA,CAAA,mBAAA;;;AAK/B;;;;AAuBF;;AC9ED,cAAA,yBAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX;AAEA;AAEA;+CAEgC,iCAAA,CAAA,mBAAA;;;AAK/B;;;;AAKF;;;;"}

package/checkbox/index.d.ts

@@ -1,10 +1,250 @@
-export * from "./abstract-checkbox-form-control.directive";
-export * from "./checkbox-context.service";
-export * from "./core-checkbox-control.directive";
-export * from "./core-checkbox-error-text.directive";
-export * from "./core-checkbox-hidden-input.directive";
-export * from "./core-checkbox-indicator.directive";
-export * from "./core-checkbox-label.directive";
-export * from "./core-checkbox-root.directive";
-export * from "./use-checkbox-group";
-//# sourceMappingURL=index.d.ts.map
+import * as _angular_core from '@angular/core';
+import { OnInit, Injector, Signal } from '@angular/core';
+import { ControlValueAccessor, FormControlStatus, NgControl, AbstractControl } from '@angular/forms';
+import { FormEventData } from '@qualcomm-ui/angular-core/forms';
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+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_checkbox from '@qualcomm-ui/core/checkbox';
+import { CheckboxApi, CheckboxApiProps } from '@qualcomm-ui/core/checkbox';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { Direction } from '@qualcomm-ui/utils/direction';
+
+declare abstract class AbstractCheckboxFormControlDirective implements ControlValueAccessor, OnInit {
+    /**
+     * The initial checked state of the checkbox when rendered. Use when you don't
+     * need to control the checked state of the checkbox. This property will be
+     * ignored if you opt into controlled state via form control bindings.
+     */
+    readonly defaultChecked: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * 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>;
+    /**
+     * The name of the input field in a checkbox. 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>;
+    /**
+     * Event emitted when the checkbox is checked or unchecked. This is only emitted
+     * on interaction. It doesn't emit in response to programmatic form control
+     * changes.
+     */
+    readonly checkedChanged: _angular_core.OutputEmitterRef<boolean>;
+    protected readonly checked: _angular_core.WritableSignal<boolean>;
+    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>;
+    protected readonly ngControl: NgControl | null;
+    protected readonly formEventData: _angular_core.WritableSignal<FormEventData<boolean | undefined> | null>;
+    /**
+     * 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 invalid: _angular_core.Signal<boolean>;
+    readonly isRequired: _angular_core.WritableSignal<boolean | undefined>;
+    constructor();
+    ngOnInit(): void;
+    /** `true` when used with template-driven forms (`[(ngModel)]`, `ngModel`, …). */
+    get isTemplateDrivenForm(): boolean;
+    /** `true` when used with reactive-forms (`formControl`, `formControlName`, …). */
+    get isReactiveForm(): boolean;
+    /** Convenience access to the underlying AbstractControl (can be null). */
+    protected 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<AbstractCheckboxFormControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AbstractCheckboxFormControlDirective, never, never, { "defaultChecked": { "alias": "defaultChecked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "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; }; }, { "checkedChanged": "checkedChanged"; }, never, never, true, never>;
+}
+
+declare class CheckboxContextService extends BaseApiContextService<CheckboxApi> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CheckboxContextService>;
+}
+declare const CHECKBOX_CONTEXT: _angular_core.InjectionToken<() => CheckboxApi>;
+declare const useCheckboxContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => CheckboxApi) | null : () => CheckboxApi;
+declare const provideCheckboxContext: () => _angular_core.Provider[];
+
+declare class CoreCheckboxControlDirective 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 checkboxContext: () => _qualcomm_ui_core_checkbox.CheckboxApi;
+    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<CoreCheckboxControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreCheckboxControlDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreCheckboxErrorTextDirective 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 checkboxContext: () => _qualcomm_ui_core_checkbox.CheckboxApi;
+    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<CoreCheckboxErrorTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreCheckboxErrorTextDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreCheckboxHiddenInputDirective 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 checkboxContext: () => _qualcomm_ui_core_checkbox.CheckboxApi;
+    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<CoreCheckboxHiddenInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreCheckboxHiddenInputDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreCheckboxIndicatorDirective implements OnInit {
+    protected readonly checkboxContext: () => _qualcomm_ui_core_checkbox.CheckboxApi;
+    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<CoreCheckboxIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreCheckboxIndicatorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreCheckboxLabelDirective 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 checkboxContext: () => _qualcomm_ui_core_checkbox.CheckboxApi;
+    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<CoreCheckboxLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreCheckboxLabelDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreCheckboxRootDirective extends AbstractCheckboxFormControlDirective implements SignalifyInput<Omit<CheckboxApiProps, "checked" | "form" | "ids">>, ControlValueAccessor, OnInit {
+    /**
+     * The document's text/writing direction.
+     *
+     * @default "ltr"
+     */
+    readonly dir: _angular_core.InputSignal<Direction | 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>;
+    /**
+     * If true and the checkbox is not checked, the checkbox will be in the
+     * `indeterminate` state.
+     */
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * {@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>;
+    /**
+     * The value of checkbox input. Useful for form submission.
+     * @default "on"
+     */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    protected readonly checkboxContextService: CheckboxContextService;
+    protected readonly document: Document;
+    protected readonly hostId: _angular_core.Signal<string>;
+    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<CoreCheckboxRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreCheckboxRootDirective, never, never, { "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "getRootNode": { "alias": "getRootNode"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface UseCheckboxGroupProps {
+    /**
+     * The initial value of `value` when uncontrolled
+     */
+    defaultValue?: Signal<string[] | undefined> | string[] | undefined;
+    /**
+     * If `true`, the checkbox group is disabled
+     */
+    disabled?: boolean | undefined;
+    /**
+     * The callback to call when the value changes
+     */
+    onValueChange?: ((value: string[]) => void) | undefined;
+    /**
+     * If `true`, the checkbox group is read-only
+     */
+    readOnly?: boolean | undefined;
+    /**
+     * The controlled value of the checkbox group
+     */
+    value?: Signal<string[] | undefined>;
+}
+interface CheckboxGroupState {
+    isChecked: (val: string | undefined) => boolean;
+    removeValue: (val: string) => void;
+    setValue: (value: string[]) => void;
+    toggleValue: (val: string) => void;
+    value: Signal<string[]>;
+}
+declare function useCheckboxGroup(props?: UseCheckboxGroupProps): CheckboxGroupState;
+
+export { AbstractCheckboxFormControlDirective, CHECKBOX_CONTEXT, CheckboxContextService, CoreCheckboxControlDirective, CoreCheckboxErrorTextDirective, CoreCheckboxHiddenInputDirective, CoreCheckboxIndicatorDirective, CoreCheckboxLabelDirective, CoreCheckboxRootDirective, provideCheckboxContext, useCheckboxContext, useCheckboxGroup };
+export type { CheckboxGroupState, UseCheckboxGroupProps };
+//# sourceMappingURL=index.d.ts.map

package/checkbox/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/checkbox/index.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAA;AAC1D,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mCAAmC,CAAA;AACjD,cAAc,sCAAsC,CAAA;AACpD,cAAc,wCAAwC,CAAA;AACtD,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/checkbox/abstract-checkbox-form-control.directive.ts","../../src/checkbox/checkbox-context.service.ts","../../src/checkbox/core-checkbox-control.directive.ts","../../src/checkbox/core-checkbox-error-text.directive.ts","../../src/checkbox/core-checkbox-hidden-input.directive.ts","../../src/checkbox/core-checkbox-indicator.directive.ts","../../src/checkbox/core-checkbox-label.directive.ts","../../src/checkbox/core-checkbox-root.directive.ts","../../src/checkbox/use-checkbox-group.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;;;AAwCA;AAIE;;;;AAIG;;AAKH;;;;AAIG;;AAKH;;AAEG;;AAGH;;;AAGG;;AAKH;;;AAGG;;AAKH;;;;AAIG;;AAIH;AACA;AACA;AACA;AAGA;;AAOA;AAIA;;;AAGG;AACH;;;;;;;;;;AA4JA;AAIA;;AAEG;AACH;AA2BA;AAKA;;;AAWA;AAIA;;;;AAIG;AACH;;;AAGD;;AC9TD;;;AACiF;AAEjF;AACkB;AACE;;ACPpB;AAEE;;;AAGG;;AAGH;;;;AAOC;AAED;AAEA;;;;AAKD;;ACxBD;AAEE;;;AAGG;;AAGH;;;;AAOC;AAED;AAEA;;;;AAKD;;ACxBD;AAEE;;;AAGG;;AAGH;;;;AAOC;AAED;AAEA;;;;AAKD;;ACzBD;AAEE;;;;AAIC;;;;AAKF;;ACVD;AAEE;;;AAGG;;AAGH;;;;AAOC;AAED;AAEA;;;;AAKD;;ACDD;AAQE;;;;AAIG;;AAGH;;;AAGG;;AAKH;;;AAGG;;AAKH;;;AAGG;;AAGH;;;AAGG;;AAGH;AACA;AAEA;;;;AAGC;;;;AAgDF;;;AC1HC;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;;AAEJ;;;AAIC;;AAEA;AACA;AACD;AAED;;;"}