@agorapulse/ui-components 18.0.35 → 18.0.36

package/directives/checkbox.directive.d.ts

@@ -0,0 +1,60 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare const AP_CHECKBOX_DIRECTIVE_CONTROL_VALUE_ACCESSOR: {
+    provide: import("@angular/core").InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
+export declare class CheckboxDirective implements ControlValueAccessor, OnInit, OnDestroy {
+    private readonly symbolRegistry;
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly viewContainer;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+    disabled: boolean;
+    set indeterminate(indeterminate: boolean);
+    get indeterminate(): boolean;
+    set checked(checked: boolean);
+    get checked(): boolean;
+    required: boolean;
+    set name(name: string);
+    get name(): string;
+    readonly change: EventEmitter<boolean>;
+    private _checked;
+    private _indeterminate;
+    private _name;
+    private _controlValueAccessorChangeFn;
+    private _onTouched;
+    private listeners;
+    private styleElement;
+    private wrapper;
+    private checkmarkContainer;
+    private indeterminateContainer;
+    private symbolComponent?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private createCheckboxStructure;
+    private createOverlayContainer;
+    private createCheckmarkSymbol;
+    private createIndeterminateBar;
+    private updateCheckmarkVisibility;
+    private setupEventListeners;
+    private applyCheckboxStyles;
+    onBlur(): void;
+    private onValueChange;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(): false | {
+        invalid: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxDirective, "input[type=\"checkbox\"][apCheckbox]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "required": { "alias": "required"; "required": false; }; "name": { "alias": "name"; "required": true; }; }, { "change": "change"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_indeterminate: unknown;
+    static ngAcceptInputType_required: unknown;
+}

package/directives/public_api.d.ts

@@ -1,5 +1,6 @@
 export * from './autosize-textarea.directive';
 export * from './base-button.directive';
+export * from './checkbox.directive';
 export * from './default-image.directive';
 export * from './ellipsis.directive';
 export * from './equal-validator.directive';

package/esm2022/directives/checkbox.directive.mjs

@@ -0,0 +1,442 @@
+import { apCheck, SymbolComponent, SymbolRegistry } from '@agorapulse/ui-symbol';
+import { booleanAttribute, Directive, ElementRef, EventEmitter, forwardRef, inject, Input, Output, Renderer2, ViewContainerRef, } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export const AP_CHECKBOX_DIRECTIVE_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => CheckboxDirective),
+    multi: true,
+};
+/*
+    Host bindings is important here:
+    - This provides encapsulation and reactivity regardless of how the directive is used in templates.
+    - It guarantees that properties like checked, disabled, required, and ARIA attributes always reflect
+    only the directive's logic, not just consumer bindings.
+    - So we need to have host bindings for all the properties that we want to control.
+    - We could also use @HostListener.
+*/
+export class CheckboxDirective {
+    symbolRegistry = inject(SymbolRegistry);
+    elementRef = inject((ElementRef));
+    renderer = inject(Renderer2);
+    viewContainer = inject(ViewContainerRef);
+    ariaLabel;
+    ariaLabelledby;
+    ariaDescribedby;
+    disabled = false;
+    set indeterminate(indeterminate) {
+        if (indeterminate) {
+            this._checked = false;
+        }
+        this._indeterminate = indeterminate;
+        const input = this.elementRef.nativeElement;
+        if (input) {
+            input.indeterminate = indeterminate;
+        }
+        // Only update visibility if containers are ready
+        if (this.checkmarkContainer && this.indeterminateContainer) {
+            this.updateCheckmarkVisibility();
+        }
+    }
+    get indeterminate() {
+        return this._indeterminate;
+    }
+    set checked(checked) {
+        this._checked = checked;
+        // Only update visibility if containers are ready
+        if (this.checkmarkContainer && this.indeterminateContainer) {
+            this.updateCheckmarkVisibility();
+        }
+    }
+    get checked() {
+        return this._checked;
+    }
+    required = false;
+    set name(name) {
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    // eslint-disable-next-line @angular-eslint/no-output-native
+    change = new EventEmitter();
+    _checked = false;
+    _indeterminate = false;
+    _name = '';
+    _controlValueAccessorChangeFn = () => { };
+    _onTouched = () => { };
+    listeners = [];
+    styleElement;
+    wrapper;
+    checkmarkContainer;
+    indeterminateContainer;
+    symbolComponent;
+    ngOnInit() {
+        this.symbolRegistry.registerSymbols([apCheck]);
+        this.createCheckboxStructure();
+        this.setupEventListeners();
+    }
+    ngOnDestroy() {
+        this.listeners.forEach(unlisten => unlisten());
+        if (this.styleElement && this.styleElement.parentNode) {
+            this.styleElement.parentNode.removeChild(this.styleElement);
+        }
+        if (this.symbolComponent) {
+            this.symbolComponent.destroy();
+        }
+        if (this.checkmarkContainer && this.checkmarkContainer.parentNode) {
+            this.checkmarkContainer.parentNode.removeChild(this.checkmarkContainer);
+        }
+        if (this.indeterminateContainer && this.indeterminateContainer.parentNode) {
+            this.indeterminateContainer.parentNode.removeChild(this.indeterminateContainer);
+        }
+        // Move input back out of wrapper and remove wrapper
+        if (this.wrapper && this.wrapper.parentNode) {
+            const input = this.elementRef.nativeElement;
+            this.renderer.insertBefore(this.wrapper.parentNode, input, this.wrapper);
+            this.wrapper.parentNode.removeChild(this.wrapper);
+        }
+    }
+    createCheckboxStructure() {
+        const input = this.elementRef.nativeElement;
+        const parent = input.parentElement;
+        // Hot take - Input doesn't need positioning since it will be wrapped
+        // Make input's parent use inline-flex for alignment
+        if (parent) {
+            this.renderer.setStyle(parent, 'display', 'inline-flex');
+            this.renderer.setStyle(parent, 'align-items', 'center');
+            this.renderer.setStyle(parent, 'gap', 'var(--ref-spacing-xxs)');
+        }
+        this.renderer.addClass(input, 'ap-checkbox-styled');
+        this.checkmarkContainer = this.createOverlayContainer('ap-checkbox-checkmark');
+        this.wrapper = this.renderer.createElement('span');
+        this.renderer.setStyle(this.wrapper, 'position', 'relative');
+        this.renderer.setStyle(this.wrapper, 'display', 'inline-flex');
+        this.renderer.setStyle(this.wrapper, 'align-items', 'center');
+        this.renderer.setStyle(this.wrapper, 'vertical-align', 'middle');
+        this.renderer.insertBefore(parent, this.wrapper, input);
+        this.renderer.appendChild(this.wrapper, input);
+        this.renderer.appendChild(this.wrapper, this.checkmarkContainer);
+        this.indeterminateContainer = this.createOverlayContainer('ap-checkbox-indeterminate');
+        this.renderer.appendChild(this.wrapper, this.indeterminateContainer);
+        this.createCheckmarkSymbol();
+        this.createIndeterminateBar();
+        this.applyCheckboxStyles();
+        this.updateCheckmarkVisibility();
+    }
+    createOverlayContainer(className) {
+        const container = this.renderer.createElement('span');
+        this.renderer.addClass(container, className);
+        this.renderer.setStyle(container, 'position', 'absolute');
+        this.renderer.setStyle(container, 'top', '50%');
+        this.renderer.setStyle(container, 'left', '50%');
+        this.renderer.setStyle(container, 'transform', 'translate(-50%, -50%)');
+        this.renderer.setStyle(container, 'width', 'auto');
+        this.renderer.setStyle(container, 'height', 'auto');
+        this.renderer.setStyle(container, 'display', 'flex');
+        this.renderer.setStyle(container, 'justify-content', 'center');
+        this.renderer.setStyle(container, 'align-items', 'center');
+        this.renderer.setStyle(container, 'pointer-events', 'none');
+        this.renderer.setStyle(container, 'opacity', '0');
+        this.renderer.setStyle(container, 'z-index', '1');
+        return container;
+    }
+    createCheckmarkSymbol() {
+        // Create the symbol component
+        this.symbolComponent = this.viewContainer.createComponent(SymbolComponent);
+        // Set inputs using setInput method for signal-based inputs
+        this.symbolComponent.setInput('symbolId', 'check');
+        this.symbolComponent.setInput('color', 'white');
+        this.symbolComponent.setInput('size', 10);
+        // Append the symbol to our checkmark container
+        this.renderer.appendChild(this.checkmarkContainer, this.symbolComponent.location.nativeElement);
+    }
+    createIndeterminateBar() {
+        // Create the indeterminate bar element exactly like the component
+        const bar = this.renderer.createElement('span');
+        this.renderer.setStyle(bar, 'height', '1.5px');
+        this.renderer.setStyle(bar, 'background', 'var(--ref-color-white)');
+        this.renderer.setStyle(bar, 'width', '8px');
+        // Append the bar to the indeterminate container
+        this.renderer.appendChild(this.indeterminateContainer, bar);
+    }
+    updateCheckmarkVisibility() {
+        if (this.checkmarkContainer) {
+            const opacity = this._checked && !this._indeterminate ? '1' : '0';
+            this.renderer.setStyle(this.checkmarkContainer, 'opacity', opacity);
+        }
+        if (this.indeterminateContainer) {
+            const opacity = this._indeterminate && !this._checked ? '1' : '0';
+            this.renderer.setStyle(this.indeterminateContainer, 'opacity', opacity);
+        }
+    }
+    setupEventListeners() {
+        const input = this.elementRef.nativeElement;
+        // Input change listener (native checkbox change)
+        const changeListener = this.renderer.listen(input, 'change', () => {
+            this.onValueChange();
+        });
+        this.listeners.push(changeListener);
+        // Listen for label clicks to ensure focus is maintained
+        const parent = input.parentElement;
+        if (parent) {
+            const labelClickListener = this.renderer.listen(parent, 'click', (event) => {
+                const target = event.target;
+                // If clicking on a label that targets our input, ensure focus
+                if (target.tagName === 'LABEL' && target.getAttribute('for') === this.name) {
+                    // Small delay to ensure the label click is processed first
+                    setTimeout(() => {
+                        input.focus();
+                    }, 0);
+                }
+            });
+            this.listeners.push(labelClickListener);
+        }
+    }
+    applyCheckboxStyles() {
+        // Style the input directly without moving DOM elements
+        const styles = `
+            /* Complete reset and custom styling for our checkbox */
+            input[type="checkbox"].ap-checkbox-styled {
+                /* Targeted reset of problematic properties */
+                appearance: none !important;
+                -webkit-appearance: none !important;
+                -moz-appearance: none !important;
+                
+                /* Our custom styling - use !important to override any global styles */
+                display: inline-block !important;
+                width: 16px !important;
+                height: 16px !important;
+                min-width: 16px !important;
+                min-height: 16px !important;
+                margin: 0 !important;
+                padding: 0 !important;
+                border: 1px solid var(--ref-color-grey-60);
+                border-radius: var(--sys-border-radius-sm);
+                background: var(--ref-color-white);
+                background-color: var(--ref-color-white);
+                box-sizing: border-box;
+                position: relative;
+                cursor: pointer;
+                vertical-align: middle;
+                
+                /* Ensure no other styles can interfere */
+                box-shadow: none;
+                text-decoration: none;
+                font: inherit;
+                color: inherit;
+                letter-spacing: normal;
+                word-spacing: normal;
+                text-transform: none;
+                text-indent: 0;
+                text-shadow: none;
+                text-align: start;
+            }
+            
+            /* Hover state */
+            input[type="checkbox"].ap-checkbox-styled:hover {
+                border-color: var(--ref-color-grey-80);
+            }
+            
+            /* Active/pressed state */
+            input[type="checkbox"].ap-checkbox-styled:active {
+                border-color: var(--ref-color-grey-100);
+            }
+            
+            /* Checked state */
+            input[type="checkbox"].ap-checkbox-styled:checked {
+                background: var(--ref-color-electric-blue-100);
+                border-color: var(--ref-color-electric-blue-100);
+            }
+            
+            /* Checked hover state */
+            input[type="checkbox"].ap-checkbox-styled:checked:hover {
+                background: var(--ref-color-electric-blue-80);
+                border-color: var(--ref-color-electric-blue-100);
+            }
+            
+            /* Checked active/pressed state */
+            input[type="checkbox"].ap-checkbox-styled:checked:active {
+                background: var(--ref-color-electric-blue-60);
+                border-color: var(--ref-color-electric-blue-100);
+            }
+            
+            /* Indeterminate state */
+            input[type="checkbox"].ap-checkbox-styled:indeterminate {
+                background: var(--ref-color-electric-blue-100);
+                border-color: var(--ref-color-electric-blue-100);
+            }
+            
+            /* Disabled state */
+            input[type="checkbox"].ap-checkbox-styled:disabled {
+                border-color: var(--ref-color-grey-20);
+                background: var(--ref-color-grey-10);
+                cursor: default;
+            }
+            
+            input[type="checkbox"].ap-checkbox-styled:disabled:checked {
+                background: var(--ref-color-grey-20);
+            }
+            
+            /* Focus state - only show on hover-capable devices like the component */
+            @media (hover: hover) {
+                input[type="checkbox"].ap-checkbox-styled:focus:not(.disabled) {
+                    outline: 3px solid var(--ref-color-electric-blue-100) !important;
+                    outline-offset: 1px !important;
+                }
+            }
+            
+            /* Label styling - targets labels that follow our wrapper containing styled checkboxes */
+            span:has(input[type="checkbox"].ap-checkbox-styled) + label {
+                display: flex;
+                align-items: center;
+                font-family: var(--comp-forms-label-font-family);
+                font-size: var(--comp-forms-label-size);
+                font-weight: var(--comp-forms-label-font-weight);
+                line-height: var(--comp-forms-label-line-height);
+                color: var(--comp-forms-label-text-color);
+            }
+            
+            /* Empty label styling */
+            span:has(input[type="checkbox"].ap-checkbox-styled) + label:empty {
+                display: none;
+            }
+            
+            /* Disabled label styling */
+            span:has(input[type="checkbox"].ap-checkbox-styled:disabled) + label {
+                color: var(--ref-color-grey-60);
+            }
+            
+            /* Label hover styling */
+            span:has(input[type="checkbox"].ap-checkbox-styled) + label:hover:not(.disabled) {
+                cursor: pointer;
+            }
+            
+            /* Disabled label hover */
+            span:has(input[type="checkbox"].ap-checkbox-styled:disabled) + label:hover {
+                cursor: default;
+            }
+        `;
+        // Create and append style element
+        this.styleElement = this.renderer.createElement('style');
+        this.renderer.appendChild(this.styleElement, this.renderer.createText(styles));
+        this.renderer.appendChild(document.head, this.styleElement);
+    }
+    onBlur() {
+        this._onTouched();
+    }
+    onValueChange() {
+        if (!this.disabled) {
+            const input = this.elementRef.nativeElement;
+            if (this._indeterminate) {
+                // When indeterminate, clicking should go to checked state
+                this._checked = true;
+                this._indeterminate = false;
+                input.checked = true;
+                input.indeterminate = false;
+            }
+            else {
+                // Normal toggle behavior
+                this._checked = input.checked;
+            }
+            this.updateCheckmarkVisibility();
+            this.change.emit(this._checked);
+            this._controlValueAccessorChangeFn(this._checked);
+        }
+    }
+    // ControlValueAccessor implementation
+    writeValue(value) {
+        this._checked = value;
+        const input = this.elementRef.nativeElement;
+        input.checked = value;
+        // Ensure indeterminate state is properly set
+        input.indeterminate = this._indeterminate;
+        this.updateCheckmarkVisibility();
+    }
+    registerOnChange(fn) {
+        this._controlValueAccessorChangeFn = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        const input = this.elementRef.nativeElement;
+        input.disabled = isDisabled;
+    }
+    validate() {
+        const isNotValid = !this._checked && this.required;
+        return (isNotValid && {
+            invalid: true,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CheckboxDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.9", type: CheckboxDirective, isStandalone: true, selector: "input[type=\"checkbox\"][apCheckbox]", inputs: { ariaLabel: ["aria-label", "ariaLabel"], ariaLabelledby: ["aria-labelledby", "ariaLabelledby"], ariaDescribedby: ["aria-describedby", "ariaDescribedby"], disabled: ["disabled", "disabled", booleanAttribute], indeterminate: ["indeterminate", "indeterminate", booleanAttribute], checked: "checked", required: ["required", "required", booleanAttribute], name: "name" }, outputs: { change: "change" }, host: { listeners: { "blur": "onBlur()" }, properties: { "disabled": "disabled", "required": "required", "checked": "checked", "attr.aria-label": "ariaLabel", "attr.aria-labelledby": "ariaLabelledby", "attr.aria-describedby": "ariaDescribedby", "attr.data-test": "name", "id": "name" } }, providers: [
+            AP_CHECKBOX_DIRECTIVE_CONTROL_VALUE_ACCESSOR,
+            {
+                provide: NG_VALIDATORS,
+                useExisting: CheckboxDirective,
+                multi: true,
+            },
+        ], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CheckboxDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[type="checkbox"][apCheckbox]',
+                    standalone: true,
+                    providers: [
+                        AP_CHECKBOX_DIRECTIVE_CONTROL_VALUE_ACCESSOR,
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: CheckboxDirective,
+                            multi: true,
+                        },
+                    ],
+                    host: {
+                        '(blur)': 'onBlur()',
+                        '[disabled]': 'disabled',
+                        '[required]': 'required',
+                        '[checked]': 'checked',
+                        '[attr.aria-label]': 'ariaLabel',
+                        '[attr.aria-labelledby]': 'ariaLabelledby',
+                        '[attr.aria-describedby]': 'ariaDescribedby',
+                        '[attr.data-test]': 'name',
+                        '[id]': 'name',
+                    },
+                }]
+        }], propDecorators: { ariaLabel: [{
+                type: Input,
+                args: ['aria-label']
+            }], ariaLabelledby: [{
+                type: Input,
+                args: ['aria-labelledby']
+            }], ariaDescribedby: [{
+                type: Input,
+                args: ['aria-describedby']
+            }], disabled: [{
+                type: Input,
+                args: [{
+                        transform: booleanAttribute,
+                    }]
+            }], indeterminate: [{
+                type: Input,
+                args: [{
+                        transform: booleanAttribute,
+                    }]
+            }], checked: [{
+                type: Input
+            }], required: [{
+                type: Input,
+                args: [{
+                        transform: booleanAttribute,
+                    }]
+            }], name: [{
+                type: Input,
+                args: [{
+                        required: true,
+                    }]
+            }], change: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkbox.directive.js","sourceRoot":"","sources":["../../../../libs/ui-components/directives/src/checkbox.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { apCheck, SymbolComponent, SymbolRegistry } from '@agorapulse/ui-symbol';\nimport {\n    booleanAttribute,\n    ComponentRef,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    forwardRef,\n    inject,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    Renderer2,\n    ViewContainerRef,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nexport const AP_CHECKBOX_DIRECTIVE_CONTROL_VALUE_ACCESSOR = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => CheckboxDirective),\n    multi: true,\n};\n\n/*\n    Host bindings is important here:\n    - This provides encapsulation and reactivity regardless of how the directive is used in templates.\n    - It guarantees that properties like checked, disabled, required, and ARIA attributes always reflect\n    only the directive's logic, not just consumer bindings.\n    - So we need to have host bindings for all the properties that we want to control.\n    - We could also use @HostListener.\n*/\n@Directive({\n    selector: 'input[type=\"checkbox\"][apCheckbox]',\n    standalone: true,\n    providers: [\n        AP_CHECKBOX_DIRECTIVE_CONTROL_VALUE_ACCESSOR,\n        {\n            provide: NG_VALIDATORS,\n            useExisting: CheckboxDirective,\n            multi: true,\n        },\n    ],\n    host: {\n        '(blur)': 'onBlur()',\n        '[disabled]': 'disabled',\n        '[required]': 'required',\n        '[checked]': 'checked',\n        '[attr.aria-label]': 'ariaLabel',\n        '[attr.aria-labelledby]': 'ariaLabelledby',\n        '[attr.aria-describedby]': 'ariaDescribedby',\n        '[attr.data-test]': 'name',\n        '[id]': 'name',\n    },\n})\nexport class CheckboxDirective implements ControlValueAccessor, OnInit, OnDestroy {\n    private readonly symbolRegistry = inject(SymbolRegistry);\n    private readonly elementRef = inject(ElementRef<HTMLInputElement>);\n    private readonly renderer = inject(Renderer2);\n    private readonly viewContainer = inject(ViewContainerRef);\n\n    @Input('aria-label') ariaLabel?: string;\n    @Input('aria-labelledby') ariaLabelledby?: string;\n    @Input('aria-describedby') ariaDescribedby?: string;\n    \n    @Input({\n        transform: booleanAttribute,\n    })\n    disabled = false;\n    \n    @Input({\n        transform: booleanAttribute,\n    })\n    set indeterminate(indeterminate: boolean) {\n        if (indeterminate) {\n            this._checked = false;\n        }\n        this._indeterminate = indeterminate;\n        const input = this.elementRef.nativeElement;\n        if (input) {\n            input.indeterminate = indeterminate;\n        }\n        // Only update visibility if containers are ready\n        if (this.checkmarkContainer && this.indeterminateContainer) {\n            this.updateCheckmarkVisibility();\n        }\n    }\n\n    get indeterminate(): boolean {\n        return this._indeterminate;\n    }\n\n    @Input() \n    set checked(checked: boolean) {\n        this._checked = checked;\n        // Only update visibility if containers are ready\n        if (this.checkmarkContainer && this.indeterminateContainer) {\n            this.updateCheckmarkVisibility();\n        }\n    }\n    \n    get checked(): boolean {\n        return this._checked;\n    }\n\n    @Input({\n        transform: booleanAttribute,\n    })\n    required = false;\n\n    @Input({\n        required: true,\n    })\n    set name(name: string) {\n        this._name = name;\n    }\n    get name(): string {\n        return this._name;\n    }\n\n    // eslint-disable-next-line @angular-eslint/no-output-native\n    @Output() readonly change: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n    private _checked = false;\n    private _indeterminate = false;\n    private _name = '';\n    private _controlValueAccessorChangeFn: (value: boolean) => void = () => {};\n    private _onTouched: () => void = () => {};\n    \n    private listeners: (() => void)[] = [];\n    private styleElement!: HTMLStyleElement;\n    private wrapper!: HTMLElement;\n    private checkmarkContainer!: HTMLElement;\n    private indeterminateContainer!: HTMLElement;\n    private symbolComponent?: ComponentRef<SymbolComponent>;\n\n    ngOnInit() {\n        this.symbolRegistry.registerSymbols([apCheck]);\n        this.createCheckboxStructure();\n        this.setupEventListeners();\n    }\n\n    ngOnDestroy(): void {\n        this.listeners.forEach(unlisten => unlisten());\n        if (this.styleElement && this.styleElement.parentNode) {\n            this.styleElement.parentNode.removeChild(this.styleElement);\n        }\n        if (this.symbolComponent) {\n            this.symbolComponent.destroy();\n        }\n        if (this.checkmarkContainer && this.checkmarkContainer.parentNode) {\n            this.checkmarkContainer.parentNode.removeChild(this.checkmarkContainer);\n        }\n        if (this.indeterminateContainer && this.indeterminateContainer.parentNode) {\n            this.indeterminateContainer.parentNode.removeChild(this.indeterminateContainer);\n        }\n        // Move input back out of wrapper and remove wrapper\n        if (this.wrapper && this.wrapper.parentNode) {\n            const input = this.elementRef.nativeElement;\n            this.renderer.insertBefore(this.wrapper.parentNode, input, this.wrapper);\n            this.wrapper.parentNode.removeChild(this.wrapper);\n        }\n    }\n\n    private createCheckboxStructure(): void {\n        const input = this.elementRef.nativeElement;\n        const parent = input.parentElement;\n        \n        // Hot take - Input doesn't need positioning since it will be wrapped\n        \n        // Make input's parent use inline-flex for alignment\n        if (parent) {\n            this.renderer.setStyle(parent, 'display', 'inline-flex');\n            this.renderer.setStyle(parent, 'align-items', 'center');\n            this.renderer.setStyle(parent, 'gap', 'var(--ref-spacing-xxs)');\n        }\n        \n        this.renderer.addClass(input, 'ap-checkbox-styled');\n        \n        this.checkmarkContainer = this.createOverlayContainer('ap-checkbox-checkmark');\n        \n        this.wrapper = this.renderer.createElement('span');\n        this.renderer.setStyle(this.wrapper, 'position', 'relative');\n        this.renderer.setStyle(this.wrapper, 'display', 'inline-flex');\n        this.renderer.setStyle(this.wrapper, 'align-items', 'center');\n        this.renderer.setStyle(this.wrapper, 'vertical-align', 'middle');\n        \n        this.renderer.insertBefore(parent, this.wrapper, input);\n        this.renderer.appendChild(this.wrapper, input);\n        \n        this.renderer.appendChild(this.wrapper, this.checkmarkContainer);\n        \n        this.indeterminateContainer = this.createOverlayContainer('ap-checkbox-indeterminate');\n        \n        this.renderer.appendChild(this.wrapper, this.indeterminateContainer);\n        \n        this.createCheckmarkSymbol();\n        this.createIndeterminateBar();\n        \n        this.applyCheckboxStyles();\n        \n        this.updateCheckmarkVisibility();\n    }\n\n    private createOverlayContainer(className: string): HTMLElement {\n        const container = this.renderer.createElement('span');\n        this.renderer.addClass(container, className);\n        this.renderer.setStyle(container, 'position', 'absolute');\n        this.renderer.setStyle(container, 'top', '50%'); \n        this.renderer.setStyle(container, 'left', '50%');   \n        this.renderer.setStyle(container, 'transform', 'translate(-50%, -50%)');\n        this.renderer.setStyle(container, 'width', 'auto'); \n        this.renderer.setStyle(container, 'height', 'auto'); \n        this.renderer.setStyle(container, 'display', 'flex');\n        this.renderer.setStyle(container, 'justify-content', 'center');\n        this.renderer.setStyle(container, 'align-items', 'center');\n        this.renderer.setStyle(container, 'pointer-events', 'none');\n        this.renderer.setStyle(container, 'opacity', '0');\n        this.renderer.setStyle(container, 'z-index', '1');\n        return container;\n    }\n\n    private createCheckmarkSymbol(): void {\n        // Create the symbol component\n        this.symbolComponent = this.viewContainer.createComponent(SymbolComponent);\n        \n        // Set inputs using setInput method for signal-based inputs\n        this.symbolComponent.setInput('symbolId', 'check');\n        this.symbolComponent.setInput('color', 'white');\n        this.symbolComponent.setInput('size', 10);\n        \n        // Append the symbol to our checkmark container\n        this.renderer.appendChild(this.checkmarkContainer, this.symbolComponent.location.nativeElement);\n    }\n\n    private createIndeterminateBar(): void {\n        // Create the indeterminate bar element exactly like the component\n        const bar = this.renderer.createElement('span');\n        this.renderer.setStyle(bar, 'height', '1.5px');\n        this.renderer.setStyle(bar, 'background', 'var(--ref-color-white)');\n        this.renderer.setStyle(bar, 'width', '8px');\n        \n        // Append the bar to the indeterminate container\n        this.renderer.appendChild(this.indeterminateContainer, bar);\n    }\n\n    private updateCheckmarkVisibility(): void {\n        if (this.checkmarkContainer) {\n            const opacity = this._checked && !this._indeterminate ? '1' : '0';\n            this.renderer.setStyle(this.checkmarkContainer, 'opacity', opacity);\n        }\n        if (this.indeterminateContainer) {\n            const opacity = this._indeterminate && !this._checked ? '1' : '0';\n            this.renderer.setStyle(this.indeterminateContainer, 'opacity', opacity);\n        }\n    }\n\n    private setupEventListeners(): void {\n        const input = this.elementRef.nativeElement;\n        \n        // Input change listener (native checkbox change)\n        const changeListener = this.renderer.listen(input, 'change', () => {\n            this.onValueChange();\n        });\n        this.listeners.push(changeListener);\n        \n        // Listen for label clicks to ensure focus is maintained\n        const parent = input.parentElement;\n        if (parent) {\n            const labelClickListener = this.renderer.listen(parent, 'click', (event: MouseEvent) => {\n                const target = event.target as HTMLElement;\n                // If clicking on a label that targets our input, ensure focus\n                if (target.tagName === 'LABEL' && target.getAttribute('for') === this.name) {\n                    // Small delay to ensure the label click is processed first\n                    setTimeout(() => {\n                        input.focus();\n                    }, 0);\n                }\n            });\n            this.listeners.push(labelClickListener);\n        }\n    }\n\n    private applyCheckboxStyles(): void {\n        // Style the input directly without moving DOM elements\n        const styles = `\n            /* Complete reset and custom styling for our checkbox */\n            input[type=\"checkbox\"].ap-checkbox-styled {\n                /* Targeted reset of problematic properties */\n                appearance: none !important;\n                -webkit-appearance: none !important;\n                -moz-appearance: none !important;\n                \n                /* Our custom styling - use !important to override any global styles */\n                display: inline-block !important;\n                width: 16px !important;\n                height: 16px !important;\n                min-width: 16px !important;\n                min-height: 16px !important;\n                margin: 0 !important;\n                padding: 0 !important;\n                border: 1px solid var(--ref-color-grey-60);\n                border-radius: var(--sys-border-radius-sm);\n                background: var(--ref-color-white);\n                background-color: var(--ref-color-white);\n                box-sizing: border-box;\n                position: relative;\n                cursor: pointer;\n                vertical-align: middle;\n                \n                /* Ensure no other styles can interfere */\n                box-shadow: none;\n                text-decoration: none;\n                font: inherit;\n                color: inherit;\n                letter-spacing: normal;\n                word-spacing: normal;\n                text-transform: none;\n                text-indent: 0;\n                text-shadow: none;\n                text-align: start;\n            }\n            \n            /* Hover state */\n            input[type=\"checkbox\"].ap-checkbox-styled:hover {\n                border-color: var(--ref-color-grey-80);\n            }\n            \n            /* Active/pressed state */\n            input[type=\"checkbox\"].ap-checkbox-styled:active {\n                border-color: var(--ref-color-grey-100);\n            }\n            \n            /* Checked state */\n            input[type=\"checkbox\"].ap-checkbox-styled:checked {\n                background: var(--ref-color-electric-blue-100);\n                border-color: var(--ref-color-electric-blue-100);\n            }\n            \n            /* Checked hover state */\n            input[type=\"checkbox\"].ap-checkbox-styled:checked:hover {\n                background: var(--ref-color-electric-blue-80);\n                border-color: var(--ref-color-electric-blue-100);\n            }\n            \n            /* Checked active/pressed state */\n            input[type=\"checkbox\"].ap-checkbox-styled:checked:active {\n                background: var(--ref-color-electric-blue-60);\n                border-color: var(--ref-color-electric-blue-100);\n            }\n            \n            /* Indeterminate state */\n            input[type=\"checkbox\"].ap-checkbox-styled:indeterminate {\n                background: var(--ref-color-electric-blue-100);\n                border-color: var(--ref-color-electric-blue-100);\n            }\n            \n            /* Disabled state */\n            input[type=\"checkbox\"].ap-checkbox-styled:disabled {\n                border-color: var(--ref-color-grey-20);\n                background: var(--ref-color-grey-10);\n                cursor: default;\n            }\n            \n            input[type=\"checkbox\"].ap-checkbox-styled:disabled:checked {\n                background: var(--ref-color-grey-20);\n            }\n            \n            /* Focus state - only show on hover-capable devices like the component */\n            @media (hover: hover) {\n                input[type=\"checkbox\"].ap-checkbox-styled:focus:not(.disabled) {\n                    outline: 3px solid var(--ref-color-electric-blue-100) !important;\n                    outline-offset: 1px !important;\n                }\n            }\n            \n            /* Label styling - targets labels that follow our wrapper containing styled checkboxes */\n            span:has(input[type=\"checkbox\"].ap-checkbox-styled) + label {\n                display: flex;\n                align-items: center;\n                font-family: var(--comp-forms-label-font-family);\n                font-size: var(--comp-forms-label-size);\n                font-weight: var(--comp-forms-label-font-weight);\n                line-height: var(--comp-forms-label-line-height);\n                color: var(--comp-forms-label-text-color);\n            }\n            \n            /* Empty label styling */\n            span:has(input[type=\"checkbox\"].ap-checkbox-styled) + label:empty {\n                display: none;\n            }\n            \n            /* Disabled label styling */\n            span:has(input[type=\"checkbox\"].ap-checkbox-styled:disabled) + label {\n                color: var(--ref-color-grey-60);\n            }\n            \n            /* Label hover styling */\n            span:has(input[type=\"checkbox\"].ap-checkbox-styled) + label:hover:not(.disabled) {\n                cursor: pointer;\n            }\n            \n            /* Disabled label hover */\n            span:has(input[type=\"checkbox\"].ap-checkbox-styled:disabled) + label:hover {\n                cursor: default;\n            }\n        `;\n        \n        // Create and append style element\n        this.styleElement = this.renderer.createElement('style');\n        this.renderer.appendChild(this.styleElement, this.renderer.createText(styles));\n        this.renderer.appendChild(document.head, this.styleElement);\n    }\n\n\n    onBlur(): void {\n        this._onTouched();\n    }\n\n    private onValueChange(): void {\n        if (!this.disabled) {\n            const input = this.elementRef.nativeElement;\n            \n            if (this._indeterminate) {\n                // When indeterminate, clicking should go to checked state\n                this._checked = true;\n                this._indeterminate = false;\n                input.checked = true;\n                input.indeterminate = false;\n            } else {\n                // Normal toggle behavior\n                this._checked = input.checked;\n            }\n            \n            this.updateCheckmarkVisibility();\n            this.change.emit(this._checked);\n            this._controlValueAccessorChangeFn(this._checked);\n        }\n    }\n\n\n    // ControlValueAccessor implementation\n    writeValue(value: boolean): void {\n        this._checked = value;\n        const input = this.elementRef.nativeElement;\n        input.checked = value;\n        // Ensure indeterminate state is properly set\n        input.indeterminate = this._indeterminate;\n        this.updateCheckmarkVisibility();\n    }\n\n    registerOnChange(fn: (value: boolean) => void): void {\n        this._controlValueAccessorChangeFn = fn;\n    }\n\n    registerOnTouched(fn: () => void): void {\n        this._onTouched = fn;\n    }\n\n    setDisabledState(isDisabled: boolean): void {\n        this.disabled = isDisabled;\n        const input = this.elementRef.nativeElement;\n        input.disabled = isDisabled;\n    }\n\n    validate() {\n        const isNotValid = !this._checked && this.required;\n        return (\n            isNotValid && {\n                invalid: true,\n            }\n        );\n    }\n}"]}

package/esm2022/directives/public_api.mjs

@@ -1,8 +1,9 @@
 export * from './autosize-textarea.directive';
 export * from './base-button.directive';
+export * from './checkbox.directive';
 export * from './default-image.directive';
 export * from './ellipsis.directive';
 export * from './equal-validator.directive';
 export * from './frozen-gif.directive';
 export * from './multi-style-text.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvdWktY29tcG9uZW50cy9kaXJlY3RpdmVzL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F1dG9zaXplLXRleHRhcmVhLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2Jhc2UtYnV0dG9uLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2RlZmF1bHQtaW1hZ2UuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZWxsaXBzaXMuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZXF1YWwtdmFsaWRhdG9yLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2Zyb3plbi1naWYuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbXVsdGktc3R5bGUtdGV4dC5kaXJlY3RpdmUnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvdWktY29tcG9uZW50cy9kaXJlY3RpdmVzL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw4QkFBOEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXV0b3NpemUtdGV4dGFyZWEuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS1idXR0b24uZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vY2hlY2tib3guZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZGVmYXVsdC1pbWFnZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9lbGxpcHNpcy5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9lcXVhbC12YWxpZGF0b3IuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZnJvemVuLWdpZi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9tdWx0aS1zdHlsZS10ZXh0LmRpcmVjdGl2ZSc7XG4iXX0=