@ngxsmk/cdk 1.3.1 → 2.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 Low-level, zoneless-friendly Angular behaviors that power NGXSMK components. Each behavior is its own secondary entry point, so you only bundle what you import.
 
-Part of the [NGXSMK UI kit](https://github.com/NGXSMK/ngxsmk-ui-kit).
+Part of the [NGXSMK UI kit](https://ngxsmk.github.io/ngxsmk-ui-kit).
 
 ## Compatibility
 

package/cva-base/cva-base.d.ts

@@ -0,0 +1,34 @@
+import { ControlValueAccessor } from '@angular/forms';
+/**
+ * Abstract base providing the CVA plumbing shared by every form component:
+ * `onChange` / `onTouched` storage, `formDisabled` signal, and the composite
+ * `isDisabled` computed. Sub-classes implement only `inputDisabled()` (the
+ * component's own `input()` signal value) and `writeValue()` (type-specific
+ * coercion).
+ *
+ * ```ts
+ * export class NgxsmkCheckbox extends CvaBase<boolean> {
+ *   readonly disabled = input(false, { transform: booleanAttribute });
+ *   protected inputDisabled() { return this.disabled(); }
+ *   writeValue(value: unknown) { this.checked.set(!!value); }
+ * }
+ * ```
+ */
+export declare abstract class CvaBase<T = unknown> implements ControlValueAccessor {
+    private _onChange;
+    private _onTouched;
+    private readonly _formDisabled;
+    /** Composite disabled state: component's own input OR form-driven disable. */
+    readonly isDisabled: import("@angular/core").Signal<boolean>;
+    /** Return the component's own `disabled` input signal value. */
+    protected abstract inputDisabled(): boolean;
+    abstract writeValue(value: unknown): void;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Fire the registered onChange callback. */
+    protected emitChange(value: T): void;
+    /** Fire the registered onTouched callback. */
+    protected emitTouched(): void;
+}
+//# sourceMappingURL=cva-base.d.ts.map

package/cva-base/cva-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cva-base.d.ts","sourceRoot":"","sources":["../../../../packages/cdk/cva-base/cva-base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,OAAO,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,oBAAoB;IAExE,OAAO,CAAC,SAAS,CAAgC;IAEjD,OAAO,CAAC,UAAU,CAAwB;IAE1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiB;IAE/C,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,0CAAgE;IAEnF,gEAAgE;IAChE,SAAS,CAAC,QAAQ,CAAC,aAAa,IAAI,OAAO;IAE3C,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAEzC,gBAAgB,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAI9C,iBAAiB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI;IAIvC,gBAAgB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI;IAI3C,6CAA6C;IAC7C,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAIpC,8CAA8C;IAC9C,SAAS,CAAC,WAAW,IAAI,IAAI;CAG9B"}

package/cva-base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cva-base';
+//# sourceMappingURL=index.d.ts.map

package/cva-base/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/cdk/cva-base/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/cva-base/ngxsmk-cdk-cva-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngxsmk-cdk-cva-base.d.ts","sourceRoot":"","sources":["../../../../packages/cdk/cva-base/ngxsmk-cdk-cva-base.ts"],"names":[],"mappings":"AAAA;;GAEG;;AAEH,cAAc,SAAS,CAAC"}

package/esm2022/cva-base/cva-base.mjs

@@ -0,0 +1,45 @@
+import { computed, signal } from '@angular/core';
+/**
+ * Abstract base providing the CVA plumbing shared by every form component:
+ * `onChange` / `onTouched` storage, `formDisabled` signal, and the composite
+ * `isDisabled` computed. Sub-classes implement only `inputDisabled()` (the
+ * component's own `input()` signal value) and `writeValue()` (type-specific
+ * coercion).
+ *
+ * ```ts
+ * export class NgxsmkCheckbox extends CvaBase<boolean> {
+ *   readonly disabled = input(false, { transform: booleanAttribute });
+ *   protected inputDisabled() { return this.disabled(); }
+ *   writeValue(value: unknown) { this.checked.set(!!value); }
+ * }
+ * ```
+ */
+export class CvaBase {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this._onChange = () => { };
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this._onTouched = () => { };
+        this._formDisabled = signal(false);
+        /** Composite disabled state: component's own input OR form-driven disable. */
+        this.isDisabled = computed(() => this.inputDisabled() || this._formDisabled());
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this._formDisabled.set(isDisabled);
+    }
+    /** Fire the registered onChange callback. */
+    emitChange(value) {
+        this._onChange(value);
+    }
+    /** Fire the registered onTouched callback. */
+    emitTouched() {
+        this._onTouched();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cva-base/index.mjs

@@ -0,0 +1,2 @@
+export * from './cva-base';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jZGsvY3ZhLWJhc2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2N2YS1iYXNlJztcbiJdfQ==

package/esm2022/cva-base/ngxsmk-cdk-cva-base.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4c21rLWNkay1jdmEtYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Nkay9jdmEtYmFzZS9uZ3hzbWstY2RrLWN2YS1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/input-group/index.mjs

@@ -0,0 +1,3 @@
+export * from './input-group-engine';
+export * from './models';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jZGsvaW5wdXQtZ3JvdXAvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5wdXQtZ3JvdXAtZW5naW5lJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJztcbiJdfQ==

package/esm2022/input-group/input-group-engine.mjs

@@ -0,0 +1,219 @@
+import { computed, signal } from '@angular/core';
+/**
+ * InputGroupEngine — headless, signal-based state machine for input group behaviour.
+ * Zero DOM, zero Angular template dependencies.
+ */
+export class InputGroupEngine {
+    constructor(config = {}) {
+        this.focused = signal(false);
+        this.hovered = signal(false);
+        this.touched = signal(false);
+        this.dirty = signal(false);
+        this.status = signal('none');
+        this.message = signal('');
+        this.disabled = signal(false);
+        this.readonly = signal(false);
+        this.passwordVisible = signal(false);
+        this.loading = signal(false);
+        this.addons = signal([]);
+        this.placeholder = signal('');
+        this.label = signal('');
+        this.hint = signal('');
+        this.required = signal(false);
+        this.maxLength = signal(undefined);
+        this.minLength = signal(undefined);
+        this.showClear = signal(false);
+        this.showCounter = signal(false);
+        this.fullWidth = signal(true);
+        this.floatingLabel = signal(false);
+        this._asyncTimer = null;
+        this._config = config;
+        // Initialize config signals
+        this.value = signal(config.initialValue ?? '');
+        this.type = signal(config.type ?? 'text');
+        this.variant = signal(config.variant ?? 'outlined');
+        this.size = signal(config.size ?? 'md');
+        this.radius = signal(config.radius ?? 'md');
+        this.density = signal(config.density ?? 'comfortable');
+        this.disabled.set(config.disabled ?? false);
+        this.readonly.set(config.readonly ?? false);
+        this.placeholder.set(config.placeholder ?? '');
+        this.label.set(config.label ?? '');
+        this.hint.set(config.hint ?? '');
+        this.required.set(config.required ?? false);
+        this.maxLength.set(config.maxLength);
+        this.minLength.set(config.minLength);
+        this.showClear.set(config.showClear ?? false);
+        this.showCounter.set(config.showCounter ?? false);
+        this.fullWidth.set(config.fullWidth ?? true);
+        this.floatingLabel.set(config.floatingLabel ?? false);
+        if (config.initialValue) {
+            this.dirty.set(true);
+            this.touched.set(true);
+        }
+        // Lifecycle hooks
+        this.onFocus = signal(() => {
+            /* noop */
+        });
+        this.onBlur = signal(() => {
+            /* noop */
+        });
+        this.onChange = signal(() => {
+            /* noop */
+        });
+        this.onClear = signal(() => {
+            /* noop */
+        });
+        this.onValidationChange = signal(() => {
+            /* noop */
+        });
+        // ── Computed ──
+        this.charCount = computed(() => this.value().length);
+        this.hasContent = computed(() => this.value().length > 0);
+        this.isActive = computed(() => this.focused() || this.hasContent());
+        this.isOverLength = computed(() => {
+            const max = this.maxLength();
+            return max != null ? this.value().length > max : false;
+        });
+        this.isUnderLength = computed(() => {
+            const min = this.minLength();
+            return min != null && this.touched() ? this.value().length < min : false;
+        });
+        this.hasError = computed(() => this.status() === 'error');
+        this.hasSuccess = computed(() => this.status() === 'success');
+        this.hasWarning = computed(() => this.status() === 'warning');
+        this.isInvalid = computed(() => this.hasError() || this.isOverLength() || this.isUnderLength());
+        this.showPlaceholder = computed(() => {
+            return !this.hasContent() && !this.focused();
+        });
+        this.shouldFloat = computed(() => {
+            if (this.floatingLabel())
+                return this.isActive() || this.hasContent();
+            return false;
+        });
+        this.leadingAddons = computed(() => this.addons().filter((a) => a.position === 'leading'));
+        this.trailingAddons = computed(() => this.addons().filter((a) => a.position === 'trailing'));
+        this.hasLeading = computed(() => this.leadingAddons().length > 0);
+        this.hasTrailing = computed(() => this.trailingAddons().length > 0);
+        this.inputType = computed(() => {
+            if (this.type() === 'password') {
+                return this.passwordVisible() ? 'text' : 'password';
+            }
+            return this.type();
+        });
+    }
+    // ── Value Operations ──
+    setValue(value) {
+        this.value.set(value);
+        this.dirty.set(true);
+        this._runValidation(value);
+        this.onChange()(value);
+    }
+    clear() {
+        this.setValue('');
+        this.onClear()();
+    }
+    getValue() {
+        return this.value();
+    }
+    // ── Focus Operations ──
+    focus() {
+        this.focused.set(true);
+        this.onFocus()();
+    }
+    blur() {
+        this.focused.set(false);
+        this.touched.set(true);
+        this._runValidation(this.value());
+        this.onBlur()();
+    }
+    // ── Password ──
+    togglePasswordVisibility() {
+        this.passwordVisible.update((v) => !v);
+    }
+    // ── Loading ──
+    showLoading() {
+        this.loading.set(true);
+    }
+    hideLoading() {
+        this.loading.set(false);
+    }
+    // ── Add-ons ──
+    addAddon(addon) {
+        this.addons.update((list) => [...list, addon]);
+    }
+    removeAddon(id) {
+        this.addons.update((list) => list.filter((a) => a.id !== id));
+    }
+    // ── Validation ──
+    setStatus(status, message = '') {
+        this.status.set(status);
+        this.message.set(message);
+        this.onValidationChange()(status, message);
+    }
+    _runValidation(value) {
+        const validator = this._config.validator;
+        if (validator) {
+            const result = validator(value);
+            this.status.set(result.status);
+            this.message.set(result.message);
+            this.onValidationChange()(result.status, result.message);
+            return;
+        }
+        // Built-in validations
+        if (this.required() && !value) {
+            this.status.set('error');
+            this.message.set('This field is required');
+            this.onValidationChange()('error', 'This field is required');
+            return;
+        }
+        if (this.isOverLength()) {
+            this.status.set('error');
+            this.message.set(`Maximum ${this.maxLength()} characters`);
+            this.onValidationChange()('error', `Maximum ${this.maxLength()} characters`);
+            return;
+        }
+        if (this.isUnderLength()) {
+            this.status.set('error');
+            this.message.set(`Minimum ${this.minLength()} characters`);
+            this.onValidationChange()('error', `Minimum ${this.minLength()} characters`);
+            return;
+        }
+        this.status.set('none');
+        this.message.set('');
+        this.onValidationChange()('none', '');
+        // Async validation
+        const asyncValidator = this._config.asyncValidator;
+        if (asyncValidator && value) {
+            if (this._asyncTimer)
+                clearTimeout(this._asyncTimer);
+            this.status.set('pending');
+            this.message.set('');
+            this._asyncTimer = setTimeout(async () => {
+                const result = await asyncValidator(value);
+                if (this.value() === value) {
+                    this.status.set(result);
+                    this.onValidationChange()(result, '');
+                }
+            }, this._config.asyncDebounce ?? 300);
+        }
+    }
+    // ── Reset ──
+    reset() {
+        this.value.set(this._config.initialValue ?? '');
+        this.focused.set(false);
+        this.touched.set(false);
+        this.dirty.set(false);
+        this.status.set('none');
+        this.message.set('');
+        this.passwordVisible.set(false);
+    }
+    // ── Enable/Disable ──
+    enable() {
+        this.disabled.set(false);
+    }
+    disable() {
+        this.disabled.set(true);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-group-engine.js","sourceRoot":"","sources":["../../../../../packages/cdk/input-group/input-group-engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAoC,MAAM,eAAe,CAAC;AAuBnF;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IA4D3B,YAAY,SAAiC,EAAE;QAzDtC,YAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACxB,YAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACxB,YAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACxB,UAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACtB,WAAM,GAAG,MAAM,CAAmB,MAAM,CAAC,CAAC;QAC1C,YAAO,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACrB,aAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACzB,aAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACzB,oBAAe,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAChC,YAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACxB,WAAM,GAAG,MAAM,CAAoB,EAAE,CAAC,CAAC;QAQvC,gBAAW,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACzB,UAAK,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QACnB,SAAI,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;QAClB,aAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACzB,cAAS,GAAG,MAAM,CAAqB,SAAS,CAAC,CAAC;QAClD,cAAS,GAAG,MAAM,CAAqB,SAAS,CAAC,CAAC;QAClD,cAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1B,gBAAW,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,cAAS,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QACzB,kBAAa,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QA4B/B,gBAAW,GAAyC,IAAI,CAAC;QAG/D,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QAEtB,4BAA4B;QAC5B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC;QAC/C,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,IAAI,UAAU,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;QACxC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,IAAI,aAAa,CAAC,CAAC;QACvD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC;QAC/C,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QACjC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACrC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACrC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,IAAI,KAAK,CAAC,CAAC;QAC9C,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,IAAI,KAAK,CAAC,CAAC;QAClD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;QAC7C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,IAAI,KAAK,CAAC,CAAC;QAEtD,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACrB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAED,kBAAkB;QAClB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,GAAG,EAAE;YACzB,UAAU;QACZ,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,EAAE;YACxB,UAAU;QACZ,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,GAAG,EAAE;YAC1B,UAAU;QACZ,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,GAAG,EAAE;YACzB,UAAU;QACZ,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,GAAG,EAAE;YACpC,UAAU;QACZ,CAAC,CAAC,CAAC;QAEH,iBAAiB;QAEjB,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,CAAC;QAErD,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAE1D,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAEpE,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAE;YAChC,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAC7B,OAAO,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QACzD,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE;YACjC,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAC7B,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QAC3E,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,OAAO,CAAC,CAAC;QAC1D,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,SAAS,CAAC,CAAC;QAC9D,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,SAAS,CAAC,CAAC;QAC9D,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,YAAY,EAAE,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QAEhG,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,GAAG,EAAE;YACnC,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC/B,IAAI,IAAI,CAAC,aAAa,EAAE;gBAAE,OAAO,IAAI,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACtE,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC;QAE3F,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC;QAE7F,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAClE,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAEpE,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC7B,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,UAAU,EAAE,CAAC;gBAC/B,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC;YACtD,CAAC;YACD,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;QACrB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,yBAAyB;IAEzB,QAAQ,CAAC,KAAa;QACpB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC3B,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAClB,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;IACnB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,yBAAyB;IAEzB,KAAK;QACH,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;IACnB,CAAC;IAED,IAAI;QACF,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;IAClB,CAAC;IAED,iBAAiB;IAEjB,wBAAwB;QACtB,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAED,gBAAgB;IAEhB,WAAW;QACT,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAED,WAAW;QACT,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED,gBAAgB;IAEhB,QAAQ,CAAC,KAAsB;QAC7B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,WAAW,CAAC,EAAU;QACpB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAChE,CAAC;IAED,mBAAmB;IAEnB,SAAS,CAAC,MAAwB,EAAE,OAAO,GAAG,EAAE;QAC9C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC1B,IAAI,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,CAAC;IAEO,cAAc,CAAC,KAAa;QAClC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;QACzC,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC/B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACjC,IAAI,CAAC,kBAAkB,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;YACzD,OAAO;QACT,CAAC;QAED,uBAAuB;QACvB,IAAI,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;YAC3C,IAAI,CAAC,kBAAkB,EAAE,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC;YAC7D,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC3D,IAAI,CAAC,kBAAkB,EAAE,CAAC,OAAO,EAAE,WAAW,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC7E,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;YACzB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC3D,IAAI,CAAC,kBAAkB,EAAE,CAAC,OAAO,EAAE,WAAW,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC7E,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACrB,IAAI,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAEtC,mBAAmB;QACnB,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC;QACnD,IAAI,cAAc,IAAI,KAAK,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,WAAW;gBAAE,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACrD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC3B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACrB,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,KAAK,IAAI,EAAE;gBACvC,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,CAAC;gBAC3C,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,EAAE,CAAC;oBAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBACxB,IAAI,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,GAAG,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED,cAAc;IAEd,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACtB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACrB,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,uBAAuB;IAEvB,MAAM;QACJ,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO;QACL,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;CACF","sourcesContent":["import { computed, signal, type WritableSignal, type Signal } from '@angular/core';\nimport type {\n  InputGroupConfig,\n  InputGroupAddon,\n  InputGroupInputType,\n  InputGroupVariant,\n  InputGroupSize,\n  InputGroupRadius,\n  InputGroupDensity,\n  ValidationStatus,\n} from './models';\n\nexport interface InputGroupEngineConfig extends InputGroupConfig {\n  /** Initial value. */\n  initialValue?: string;\n  /** Async validator function. */\n  asyncValidator?: (value: string) => Promise<ValidationStatus>;\n  /** Sync validator function. */\n  validator?: (value: string) => { status: ValidationStatus; message: string };\n  /** Debounce for async validation in ms. */\n  asyncDebounce?: number;\n}\n\n/**\n * InputGroupEngine — headless, signal-based state machine for input group behaviour.\n * Zero DOM, zero Angular template dependencies.\n */\nexport class InputGroupEngine {\n  // ── Core State ──\n  readonly value: WritableSignal<string>;\n  readonly focused = signal(false);\n  readonly hovered = signal(false);\n  readonly touched = signal(false);\n  readonly dirty = signal(false);\n  readonly status = signal<ValidationStatus>('none');\n  readonly message = signal('');\n  readonly disabled = signal(false);\n  readonly readonly = signal(false);\n  readonly passwordVisible = signal(false);\n  readonly loading = signal(false);\n  readonly addons = signal<InputGroupAddon[]>([]);\n\n  // ── Config ──\n  readonly type: WritableSignal<InputGroupInputType>;\n  readonly variant: WritableSignal<InputGroupVariant>;\n  readonly size: WritableSignal<InputGroupSize>;\n  readonly radius: WritableSignal<InputGroupRadius>;\n  readonly density: WritableSignal<InputGroupDensity>;\n  readonly placeholder = signal('');\n  readonly label = signal('');\n  readonly hint = signal('');\n  readonly required = signal(false);\n  readonly maxLength = signal<number | undefined>(undefined);\n  readonly minLength = signal<number | undefined>(undefined);\n  readonly showClear = signal(false);\n  readonly showCounter = signal(false);\n  readonly fullWidth = signal(true);\n  readonly floatingLabel = signal(false);\n\n  // ── Computed ──\n  readonly charCount: Signal<number>;\n  readonly hasContent: Signal<boolean>;\n  readonly isActive: Signal<boolean>;\n  readonly isOverLength: Signal<boolean>;\n  readonly isUnderLength: Signal<boolean>;\n  readonly hasError: Signal<boolean>;\n  readonly hasSuccess: Signal<boolean>;\n  readonly hasWarning: Signal<boolean>;\n  readonly isInvalid: Signal<boolean>;\n  readonly showPlaceholder: Signal<boolean>;\n  readonly shouldFloat: Signal<boolean>;\n  readonly leadingAddons: Signal<InputGroupAddon[]>;\n  readonly trailingAddons: Signal<InputGroupAddon[]>;\n  readonly hasLeading: Signal<boolean>;\n  readonly hasTrailing: Signal<boolean>;\n  readonly inputType: Signal<InputGroupInputType>;\n\n  // ── Lifecycle Hooks ──\n  readonly onFocus: WritableSignal<() => void>;\n  readonly onBlur: WritableSignal<() => void>;\n  readonly onChange: WritableSignal<(value: string) => void>;\n  readonly onClear: WritableSignal<() => void>;\n  readonly onValidationChange: WritableSignal<(status: ValidationStatus, message: string) => void>;\n\n  private _config: InputGroupEngineConfig;\n  private _asyncTimer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor(config: InputGroupEngineConfig = {}) {\n    this._config = config;\n\n    // Initialize config signals\n    this.value = signal(config.initialValue ?? '');\n    this.type = signal(config.type ?? 'text');\n    this.variant = signal(config.variant ?? 'outlined');\n    this.size = signal(config.size ?? 'md');\n    this.radius = signal(config.radius ?? 'md');\n    this.density = signal(config.density ?? 'comfortable');\n    this.disabled.set(config.disabled ?? false);\n    this.readonly.set(config.readonly ?? false);\n    this.placeholder.set(config.placeholder ?? '');\n    this.label.set(config.label ?? '');\n    this.hint.set(config.hint ?? '');\n    this.required.set(config.required ?? false);\n    this.maxLength.set(config.maxLength);\n    this.minLength.set(config.minLength);\n    this.showClear.set(config.showClear ?? false);\n    this.showCounter.set(config.showCounter ?? false);\n    this.fullWidth.set(config.fullWidth ?? true);\n    this.floatingLabel.set(config.floatingLabel ?? false);\n\n    if (config.initialValue) {\n      this.dirty.set(true);\n      this.touched.set(true);\n    }\n\n    // Lifecycle hooks\n    this.onFocus = signal(() => {\n      /* noop */\n    });\n    this.onBlur = signal(() => {\n      /* noop */\n    });\n    this.onChange = signal(() => {\n      /* noop */\n    });\n    this.onClear = signal(() => {\n      /* noop */\n    });\n    this.onValidationChange = signal(() => {\n      /* noop */\n    });\n\n    // ── Computed ──\n\n    this.charCount = computed(() => this.value().length);\n\n    this.hasContent = computed(() => this.value().length > 0);\n\n    this.isActive = computed(() => this.focused() || this.hasContent());\n\n    this.isOverLength = computed(() => {\n      const max = this.maxLength();\n      return max != null ? this.value().length > max : false;\n    });\n\n    this.isUnderLength = computed(() => {\n      const min = this.minLength();\n      return min != null && this.touched() ? this.value().length < min : false;\n    });\n\n    this.hasError = computed(() => this.status() === 'error');\n    this.hasSuccess = computed(() => this.status() === 'success');\n    this.hasWarning = computed(() => this.status() === 'warning');\n    this.isInvalid = computed(() => this.hasError() || this.isOverLength() || this.isUnderLength());\n\n    this.showPlaceholder = computed(() => {\n      return !this.hasContent() && !this.focused();\n    });\n\n    this.shouldFloat = computed(() => {\n      if (this.floatingLabel()) return this.isActive() || this.hasContent();\n      return false;\n    });\n\n    this.leadingAddons = computed(() => this.addons().filter((a) => a.position === 'leading'));\n\n    this.trailingAddons = computed(() => this.addons().filter((a) => a.position === 'trailing'));\n\n    this.hasLeading = computed(() => this.leadingAddons().length > 0);\n    this.hasTrailing = computed(() => this.trailingAddons().length > 0);\n\n    this.inputType = computed(() => {\n      if (this.type() === 'password') {\n        return this.passwordVisible() ? 'text' : 'password';\n      }\n      return this.type();\n    });\n  }\n\n  // ── Value Operations ──\n\n  setValue(value: string): void {\n    this.value.set(value);\n    this.dirty.set(true);\n    this._runValidation(value);\n    this.onChange()(value);\n  }\n\n  clear(): void {\n    this.setValue('');\n    this.onClear()();\n  }\n\n  getValue(): string {\n    return this.value();\n  }\n\n  // ── Focus Operations ──\n\n  focus(): void {\n    this.focused.set(true);\n    this.onFocus()();\n  }\n\n  blur(): void {\n    this.focused.set(false);\n    this.touched.set(true);\n    this._runValidation(this.value());\n    this.onBlur()();\n  }\n\n  // ── Password ──\n\n  togglePasswordVisibility(): void {\n    this.passwordVisible.update((v) => !v);\n  }\n\n  // ── Loading ──\n\n  showLoading(): void {\n    this.loading.set(true);\n  }\n\n  hideLoading(): void {\n    this.loading.set(false);\n  }\n\n  // ── Add-ons ──\n\n  addAddon(addon: InputGroupAddon): void {\n    this.addons.update((list) => [...list, addon]);\n  }\n\n  removeAddon(id: string): void {\n    this.addons.update((list) => list.filter((a) => a.id !== id));\n  }\n\n  // ── Validation ──\n\n  setStatus(status: ValidationStatus, message = ''): void {\n    this.status.set(status);\n    this.message.set(message);\n    this.onValidationChange()(status, message);\n  }\n\n  private _runValidation(value: string): void {\n    const validator = this._config.validator;\n    if (validator) {\n      const result = validator(value);\n      this.status.set(result.status);\n      this.message.set(result.message);\n      this.onValidationChange()(result.status, result.message);\n      return;\n    }\n\n    // Built-in validations\n    if (this.required() && !value) {\n      this.status.set('error');\n      this.message.set('This field is required');\n      this.onValidationChange()('error', 'This field is required');\n      return;\n    }\n\n    if (this.isOverLength()) {\n      this.status.set('error');\n      this.message.set(`Maximum ${this.maxLength()} characters`);\n      this.onValidationChange()('error', `Maximum ${this.maxLength()} characters`);\n      return;\n    }\n\n    if (this.isUnderLength()) {\n      this.status.set('error');\n      this.message.set(`Minimum ${this.minLength()} characters`);\n      this.onValidationChange()('error', `Minimum ${this.minLength()} characters`);\n      return;\n    }\n\n    this.status.set('none');\n    this.message.set('');\n    this.onValidationChange()('none', '');\n\n    // Async validation\n    const asyncValidator = this._config.asyncValidator;\n    if (asyncValidator && value) {\n      if (this._asyncTimer) clearTimeout(this._asyncTimer);\n      this.status.set('pending');\n      this.message.set('');\n      this._asyncTimer = setTimeout(async () => {\n        const result = await asyncValidator(value);\n        if (this.value() === value) {\n          this.status.set(result);\n          this.onValidationChange()(result, '');\n        }\n      }, this._config.asyncDebounce ?? 300);\n    }\n  }\n\n  // ── Reset ──\n\n  reset(): void {\n    this.value.set(this._config.initialValue ?? '');\n    this.focused.set(false);\n    this.touched.set(false);\n    this.dirty.set(false);\n    this.status.set('none');\n    this.message.set('');\n    this.passwordVisible.set(false);\n  }\n\n  // ── Enable/Disable ──\n\n  enable(): void {\n    this.disabled.set(false);\n  }\n\n  disable(): void {\n    this.disabled.set(true);\n  }\n}\n"]}

package/esm2022/input-group/models/index.mjs

@@ -0,0 +1,2 @@
+export * from './input-group.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jZGsvaW5wdXQtZ3JvdXAvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2lucHV0LWdyb3VwLm1vZGVsJztcbiJdfQ==

package/esm2022/input-group/models/input-group.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtZ3JvdXAubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jZGsvaW5wdXQtZ3JvdXAvbW9kZWxzL2lucHV0LWdyb3VwLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogU3VwcG9ydGVkIEhUTUwgaW5wdXQgdHlwZXMgdGhhdCB0aGUgZ3JvdXAgY2FuIHdyYXAuICovXG5leHBvcnQgdHlwZSBJbnB1dEdyb3VwSW5wdXRUeXBlID1cbiAgfCAndGV4dCdcbiAgfCAncGFzc3dvcmQnXG4gIHwgJ2VtYWlsJ1xuICB8ICdudW1iZXInXG4gIHwgJ3NlYXJjaCdcbiAgfCAndGVsJ1xuICB8ICd1cmwnXG4gIHwgJ2RhdGUnXG4gIHwgJ3RpbWUnXG4gIHwgJ2RhdGV0aW1lLWxvY2FsJ1xuICB8ICdjb2xvcidcbiAgfCAnZmlsZSc7XG5cbi8qKiBWaXN1YWwgdmFyaWFudCBvZiB0aGUgaW5wdXQgZ3JvdXAgY29udGFpbmVyLiAqL1xuZXhwb3J0IHR5cGUgSW5wdXRHcm91cFZhcmlhbnQgPSAnb3V0bGluZWQnIHwgJ2ZpbGxlZCcgfCAnc29mdCcgfCAnZ2hvc3QnIHwgJ3VuZGVybGluZSc7XG5cbi8qKiBTaXplIHByZXNldCBjb250cm9sbGluZyBoZWlnaHQsIHBhZGRpbmcsIGFuZCBmb250IHNpemUuICovXG5leHBvcnQgdHlwZSBJbnB1dEdyb3VwU2l6ZSA9ICdzbScgfCAnbWQnIHwgJ2xnJyB8ICd4bCc7XG5cbi8qKiBDb3JuZXIgcmFkaXVzIHByZXNldC4gKi9cbmV4cG9ydCB0eXBlIElucHV0R3JvdXBSYWRpdXMgPSAnbm9uZScgfCAnc20nIHwgJ21kJyB8ICdsZycgfCAneGwnIHwgJ3BpbGwnO1xuXG4vKiogRGVuc2l0eSBwcmVzZXQgY29udHJvbGxpbmcgc3BhY2luZy4gKi9cbmV4cG9ydCB0eXBlIElucHV0R3JvdXBEZW5zaXR5ID0gJ2NvbXBhY3QnIHwgJ2NvbWZvcnRhYmxlJyB8ICdzcGFjaW91cyc7XG5cbi8qKiBWYWxpZGF0aW9uIHN0YXR1cyBkaXNwbGF5ZWQgb24gdGhlIGdyb3VwLiAqL1xuZXhwb3J0IHR5cGUgVmFsaWRhdGlvblN0YXR1cyA9ICdlcnJvcicgfCAnd2FybmluZycgfCAnc3VjY2VzcycgfCAnaW5mbycgfCAncGVuZGluZycgfCAnbm9uZSc7XG5cbi8qKiBQb3NpdGlvbiBvZiBhbiBhZGQtb24gZWxlbWVudC4gKi9cbmV4cG9ydCB0eXBlIEFkZG9uUG9zaXRpb24gPSAnbGVhZGluZycgfCAndHJhaWxpbmcnO1xuXG4vKiogQ29udGVudCB0eXBlIGZvciBhbiBhZGQtb24gc2xvdC4gKi9cbmV4cG9ydCB0eXBlIEFkZG9uQ29udGVudFR5cGUgPVxuICAndGV4dCcgfCAnaWNvbicgfCAnYnV0dG9uJyB8ICdhdmF0YXInIHwgJ2JhZGdlJyB8ICdjaGlwJyB8ICd0b2dnbGUnIHwgJ3NwaW5uZXInIHwgJ2N1c3RvbSc7XG5cbi8qKiBDb25maWd1cmF0aW9uIGZvciBhIHNpbmdsZSBhZGQtb24gZWxlbWVudC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSW5wdXRHcm91cEFkZG9uIHtcbiAgLyoqIFVuaXF1ZSBrZXkgZm9yIHRyYWNraW5nLiAqL1xuICByZWFkb25seSBpZDogc3RyaW5nO1xuICAvKiogUG9zaXRpb246IGxlYWRpbmcgb3IgdHJhaWxpbmcuICovXG4gIHJlYWRvbmx5IHBvc2l0aW9uOiBBZGRvblBvc2l0aW9uO1xuICAvKiogV2hhdCBraW5kIG9mIGNvbnRlbnQgdGhpcyBhZGQtb24gaG9sZHMuICovXG4gIHJlYWRvbmx5IGNvbnRlbnRUeXBlOiBBZGRvbkNvbnRlbnRUeXBlO1xuICAvKiogVGV4dCBjb250ZW50ICh3aGVuIGNvbnRlbnRUeXBlIGlzICd0ZXh0JykuICovXG4gIHJlYWRvbmx5IHRleHQ/OiBzdHJpbmc7XG4gIC8qKiBJY29uIG5hbWUgb3IgU1ZHIHBhdGggKHdoZW4gY29udGVudFR5cGUgaXMgJ2ljb24nKS4gKi9cbiAgcmVhZG9ubHkgaWNvbj86IHN0cmluZztcbiAgLyoqIFdoZXRoZXIgdGhpcyBhZGQtb24gaXMgaW50ZXJhY3RpdmUgKGNsaWNrYWJsZSkuICovXG4gIHJlYWRvbmx5IGludGVyYWN0aXZlPzogYm9vbGVhbjtcbiAgLyoqIFdoZXRoZXIgdGhpcyBhZGQtb24gaXMgZGlzYWJsZWQuICovXG4gIHJlYWRvbmx5IGRpc2FibGVkPzogYm9vbGVhbjtcbiAgLyoqIEN1c3RvbSBDU1MgY2xhc3MgYXBwbGllZCB0byB0aGUgYWRkLW9uIGVsZW1lbnQuICovXG4gIHJlYWRvbmx5IGNsYXNzTmFtZT86IHN0cmluZztcbiAgLyoqIEFSSUEgbGFiZWwgZm9yIHRoZSBhZGQtb24uICovXG4gIHJlYWRvbmx5IGFyaWFMYWJlbD86IHN0cmluZztcbiAgLyoqIFRvb2x0aXAgdGV4dCBmb3IgdGhlIGFkZC1vbi4gKi9cbiAgcmVhZG9ubHkgdG9vbHRpcD86IHN0cmluZztcbiAgLyoqIFRlbXBsYXRlIGtleSBmb3IgY3VzdG9tIHJlbmRlcmluZy4gKi9cbiAgcmVhZG9ubHkgdGVtcGxhdGVLZXk/OiBzdHJpbmc7XG59XG5cbi8qKiBGdWxsIGNvbmZpZ3VyYXRpb24gZm9yIHRoZSBpbnB1dCBncm91cC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSW5wdXRHcm91cENvbmZpZyB7XG4gIC8qKiBIVE1MIGlucHV0IHR5cGUuICovXG4gIHR5cGU/OiBJbnB1dEdyb3VwSW5wdXRUeXBlO1xuICAvKiogVmlzdWFsIHZhcmlhbnQuICovXG4gIHZhcmlhbnQ/OiBJbnB1dEdyb3VwVmFyaWFudDtcbiAgLyoqIFNpemUuICovXG4gIHNpemU/OiBJbnB1dEdyb3VwU2l6ZTtcbiAgLyoqIENvcm5lciByYWRpdXMuICovXG4gIHJhZGl1cz86IElucHV0R3JvdXBSYWRpdXM7XG4gIC8qKiBEZW5zaXR5LiAqL1xuICBkZW5zaXR5PzogSW5wdXRHcm91cERlbnNpdHk7XG4gIC8qKiBXaGV0aGVyIHRoZSBlbnRpcmUgZ3JvdXAgaXMgZGlzYWJsZWQuICovXG4gIGRpc2FibGVkPzogYm9vbGVhbjtcbiAgLyoqIFdoZXRoZXIgdGhlIGlucHV0IGlzIHJlYWQtb25seS4gKi9cbiAgcmVhZG9ubHk/OiBib29sZWFuO1xuICAvKiogUGxhY2Vob2xkZXIgdGV4dC4gKi9cbiAgcGxhY2Vob2xkZXI/OiBzdHJpbmc7XG4gIC8qKiBMYWJlbCB0ZXh0IChjYW4gYWxzbyBiZSBwcm92aWRlZCB2aWEgdGVtcGxhdGUpLiAqL1xuICBsYWJlbD86IHN0cmluZztcbiAgLyoqIEhpbnQgdGV4dCBiZWxvdyB0aGUgaW5wdXQuICovXG4gIGhpbnQ/OiBzdHJpbmc7XG4gIC8qKiBXaGV0aGVyIHRoZSBpbnB1dCBpcyByZXF1aXJlZC4gKi9cbiAgcmVxdWlyZWQ/OiBib29sZWFuO1xuICAvKiogTWF4aW11bSBjaGFyYWN0ZXIgbGVuZ3RoLiAqL1xuICBtYXhMZW5ndGg/OiBudW1iZXI7XG4gIC8qKiBNaW5pbXVtIGNoYXJhY3RlciBsZW5ndGguICovXG4gIG1pbkxlbmd0aD86IG51bWJlcjtcbiAgLyoqIFdoZXRoZXIgdG8gc2hvdyBhIGNsZWFyIGJ1dHRvbi4gKi9cbiAgc2hvd0NsZWFyPzogYm9vbGVhbjtcbiAgLyoqIFdoZXRoZXIgdG8gc2hvdyBhIGNoYXJhY3RlciBjb3VudGVyLiAqL1xuICBzaG93Q291bnRlcj86IGJvb2xlYW47XG4gIC8qKiBXaGV0aGVyIHRoZSBpbnB1dCB0YWtlcyBmdWxsIHdpZHRoLiAqL1xuICBmdWxsV2lkdGg/OiBib29sZWFuO1xuICAvKiogV2hldGhlciB0aGUgaW5wdXQgaXMgbG9hZGluZy4gKi9cbiAgbG9hZGluZz86IGJvb2xlYW47XG4gIC8qKiBXaGV0aGVyIHRoZSBpbnB1dCBncm91cCBzdXBwb3J0cyBSVEwuICovXG4gIHJ0bD86IGJvb2xlYW47XG4gIC8qKiBGbG9hdGluZyBsYWJlbCBtb2RlLiAqL1xuICBmbG9hdGluZ0xhYmVsPzogYm9vbGVhbjtcbn1cblxuLyoqIFJ1bnRpbWUgc3RhdGUgdHJhY2tlZCBieSB0aGUgZW5naW5lLiAqL1xuZXhwb3J0IGludGVyZmFjZSBJbnB1dEdyb3VwU3RhdGUge1xuICAvKiogQ3VycmVudCB2YWx1ZS4gKi9cbiAgcmVhZG9ubHkgdmFsdWU6IHN0cmluZztcbiAgLyoqIFdoZXRoZXIgdGhlIGlucHV0IGhhcyBmb2N1cy4gKi9cbiAgcmVhZG9ubHkgZm9jdXNlZDogYm9vbGVhbjtcbiAgLyoqIFdoZXRoZXIgdGhlIG1vdXNlIGlzIGhvdmVyaW5nLiAqL1xuICByZWFkb25seSBob3ZlcmVkOiBib29sZWFuO1xuICAvKiogV2hldGhlciB0aGUgdmFsdWUgaGFzIGJlZW4gdG91Y2hlZCAoYmx1cnJlZCBhdCBsZWFzdCBvbmNlKS4gKi9cbiAgcmVhZG9ubHkgdG91Y2hlZDogYm9vbGVhbjtcbiAgLyoqIFdoZXRoZXIgdGhlIHZhbHVlIGhhcyBiZWVuIG1vZGlmaWVkIGZyb20gaW5pdGlhbC4gKi9cbiAgcmVhZG9ubHkgZGlydHk6IGJvb2xlYW47XG4gIC8qKiBDdXJyZW50IHZhbGlkYXRpb24gc3RhdHVzLiAqL1xuICByZWFkb25seSBzdGF0dXM6IFZhbGlkYXRpb25TdGF0dXM7XG4gIC8qKiBWYWxpZGF0aW9uIG1lc3NhZ2UgdGV4dC4gKi9cbiAgcmVhZG9ubHkgbWVzc2FnZTogc3RyaW5nO1xuICAvKiogV2hldGhlciB0aGUgaW5wdXQgaXMgZGlzYWJsZWQuICovXG4gIHJlYWRvbmx5IGRpc2FibGVkOiBib29sZWFuO1xuICAvKiogV2hldGhlciB0aGUgaW5wdXQgaXMgcmVhZC1vbmx5LiAqL1xuICByZWFkb25seSByZWFkb25seTogYm9vbGVhbjtcbiAgLyoqIFdoZXRoZXIgdGhlIHBhc3N3b3JkIGlzIGN1cnJlbnRseSB2aXNpYmxlIChyZXZlYWwgdG9nZ2xlKS4gKi9cbiAgcmVhZG9ubHkgcGFzc3dvcmRWaXNpYmxlOiBib29sZWFuO1xuICAvKiogV2hldGhlciB0aGUgbG9hZGluZyBpbmRpY2F0b3IgaXMgc2hvd2luZy4gKi9cbiAgcmVhZG9ubHkgbG9hZGluZzogYm9vbGVhbjtcbiAgLyoqIEN1cnJlbnQgY2hhcmFjdGVyIGNvdW50LiAqL1xuICByZWFkb25seSBjaGFyQ291bnQ6IG51bWJlcjtcbiAgLyoqIFJlZ2lzdGVyZWQgYWRkLW9ucy4gKi9cbiAgcmVhZG9ubHkgYWRkb25zOiByZWFkb25seSBJbnB1dEdyb3VwQWRkb25bXTtcbiAgLyoqIFdoZXRoZXIgdGhlIGlucHV0IGhhcyBjb250ZW50IChmb3IgZmxvYXRpbmcgbGFiZWwgcG9zaXRpb25pbmcpLiAqL1xuICByZWFkb25seSBoYXNDb250ZW50OiBib29sZWFuO1xufVxuIl19

package/esm2022/input-group/ngxsmk-cdk-input-group.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4c21rLWNkay1pbnB1dC1ncm91cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Nkay9pbnB1dC1ncm91cC9uZ3hzbWstY2RrLWlucHV0LWdyb3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/listbox-keyboard/index.mjs

@@ -0,0 +1,2 @@
+export * from './listbox-keyboard';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jZGsvbGlzdGJveC1rZXlib2FyZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saXN0Ym94LWtleWJvYXJkJztcbiJdfQ==

package/esm2022/listbox-keyboard/listbox-keyboard.mjs

@@ -0,0 +1,145 @@
+import { signal } from '@angular/core';
+/**
+ * Shared arrow-key navigation for dropdown listboxes.
+ *
+ * Encapsulates `activeIndex`, `move(delta)`, `scrollActiveIntoView()`, and the
+ * full `onKeydown()` handler. Components provide only their option list and
+ * CSS selector.
+ *
+ * ```ts
+ * private readonly kb = new ListboxKeyboard({
+ *   optionSelector: '.ngxsmk-combobox__option',
+ *   options: () => this.filtered(),
+ *   host: this.host,
+ * });
+ * ```
+ */
+export class ListboxKeyboard {
+    constructor(config) {
+        this.activeIndex = signal(-1);
+        this.config = config;
+    }
+    /** Override the host element used for scroll queries (e.g. for portals). */
+    setHost(host) {
+        this.config.host = host;
+    }
+    /** Move the active index by `delta` positions, wrapping around. */
+    move(delta) {
+        const opts = this.config.options();
+        if (!opts.length)
+            return;
+        let next = this.activeIndex() + delta;
+        const min = this.config.placeholderIndex ?? 0;
+        for (let guard = 0; guard <= opts.length; guard++) {
+            if (next < min) {
+                next = opts.length - 1;
+            }
+            else if (next > opts.length - 1) {
+                next = min;
+            }
+            if (!this.config.skipDisabled || next === min || !opts[next]?.disabled) {
+                break;
+            }
+            next += delta;
+        }
+        this.activeIndex.set(next);
+        this.scrollActiveIntoView();
+    }
+    /** Scroll the active option into view within the host element. */
+    scrollActiveIntoView() {
+        requestAnimationFrame(() => {
+            const host = this.config.host?.nativeElement;
+            if (!host)
+                return;
+            const items = host.querySelectorAll(this.config.optionSelector);
+            let idx = this.activeIndex();
+            // Offset by 1 if there's a placeholder before the options
+            if (this.config.placeholderIndex !== undefined && idx >= 0) {
+                idx += 1;
+            }
+            items[idx]?.scrollIntoView({ block: 'nearest' });
+        });
+    }
+    /** Jump to the first enabled option. */
+    home() {
+        const opts = this.config.options();
+        if (!opts.length)
+            return;
+        const min = this.config.placeholderIndex ?? 0;
+        if (this.config.skipDisabled) {
+            const first = opts.findIndex((o) => !o.disabled);
+            this.activeIndex.set(first >= 0 ? first : min);
+        }
+        else {
+            this.activeIndex.set(min);
+        }
+        this.scrollActiveIntoView();
+    }
+    /** Jump to the last option. */
+    end() {
+        const opts = this.config.options();
+        if (!opts.length)
+            return;
+        this.activeIndex.set(opts.length - 1);
+        this.scrollActiveIntoView();
+    }
+    /**
+     * Handle a keyboard event for listbox navigation.
+     *
+     * @returns `true` if the event was handled, `false` if the caller should
+     *   handle it (e.g. for typeahead or open/close toggling).
+     */
+    handleKeydown(event, callbacks = {}) {
+        const opts = this.config.options();
+        const isOpen = callbacks.isOpen?.() ?? true;
+        switch (event.key) {
+            case 'ArrowDown':
+                event.preventDefault();
+                if (!isOpen) {
+                    callbacks.onOpen?.();
+                }
+                else {
+                    this.move(1);
+                }
+                return true;
+            case 'ArrowUp':
+                event.preventDefault();
+                if (isOpen) {
+                    this.move(-1);
+                }
+                return true;
+            case 'Home':
+                if (isOpen && opts.length) {
+                    event.preventDefault();
+                    this.home();
+                }
+                return true;
+            case 'End':
+                if (isOpen && opts.length) {
+                    event.preventDefault();
+                    this.end();
+                }
+                return true;
+            case 'Enter':
+            case ' ':
+            case 'Spacebar':
+                if (isOpen) {
+                    event.preventDefault();
+                    const idx = this.activeIndex();
+                    if (idx >= 0 && opts[idx]) {
+                        callbacks.onSelect?.(idx);
+                    }
+                }
+                return true;
+            case 'Escape':
+                if (isOpen) {
+                    event.preventDefault();
+                    callbacks.onClose?.();
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listbox-keyboard.js","sourceRoot":"","sources":["../../../../../packages/cdk/listbox-keyboard/listbox-keyboard.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, signal } from '@angular/core';\n\n/**\n * Configuration for listbox keyboard navigation.\n *\n * @property optionSelector - CSS selector for option elements\n * @property options - Function returning the current option list\n * @property host - Optional host element for scroll queries (defaults to inject(ElementRef))\n * @property placeholderIndex - Index for the placeholder item (-1 if none)\n * @property skipDisabled - Whether to skip disabled options during navigation\n */\nexport interface ListboxKeyboardConfig {\n  optionSelector: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  options: () => any[];\n  host?: ElementRef<HTMLElement>;\n  placeholderIndex?: number;\n  skipDisabled?: boolean;\n}\n\n/**\n * Shared arrow-key navigation for dropdown listboxes.\n *\n * Encapsulates `activeIndex`, `move(delta)`, `scrollActiveIntoView()`, and the\n * full `onKeydown()` handler. Components provide only their option list and\n * CSS selector.\n *\n * ```ts\n * private readonly kb = new ListboxKeyboard({\n *   optionSelector: '.ngxsmk-combobox__option',\n *   options: () => this.filtered(),\n *   host: this.host,\n * });\n * ```\n */\nexport class ListboxKeyboard {\n  readonly activeIndex = signal(-1);\n\n  private readonly config: ListboxKeyboardConfig;\n\n  constructor(config: ListboxKeyboardConfig) {\n    this.config = config;\n  }\n\n  /** Override the host element used for scroll queries (e.g. for portals). */\n  setHost(host: ElementRef<HTMLElement>): void {\n    this.config.host = host;\n  }\n\n  /** Move the active index by `delta` positions, wrapping around. */\n  move(delta: number): void {\n    const opts = this.config.options();\n    if (!opts.length) return;\n\n    let next = this.activeIndex() + delta;\n    const min = this.config.placeholderIndex ?? 0;\n\n    for (let guard = 0; guard <= opts.length; guard++) {\n      if (next < min) {\n        next = opts.length - 1;\n      } else if (next > opts.length - 1) {\n        next = min;\n      }\n      if (!this.config.skipDisabled || next === min || !opts[next]?.disabled) {\n        break;\n      }\n      next += delta;\n    }\n\n    this.activeIndex.set(next);\n    this.scrollActiveIntoView();\n  }\n\n  /** Scroll the active option into view within the host element. */\n  scrollActiveIntoView(): void {\n    requestAnimationFrame(() => {\n      const host = this.config.host?.nativeElement;\n      if (!host) return;\n      const items = host.querySelectorAll<HTMLElement>(this.config.optionSelector);\n      let idx = this.activeIndex();\n      // Offset by 1 if there's a placeholder before the options\n      if (this.config.placeholderIndex !== undefined && idx >= 0) {\n        idx += 1;\n      }\n      items[idx]?.scrollIntoView({ block: 'nearest' });\n    });\n  }\n\n  /** Jump to the first enabled option. */\n  home(): void {\n    const opts = this.config.options();\n    if (!opts.length) return;\n    const min = this.config.placeholderIndex ?? 0;\n    if (this.config.skipDisabled) {\n      const first = opts.findIndex((o) => !o.disabled);\n      this.activeIndex.set(first >= 0 ? first : min);\n    } else {\n      this.activeIndex.set(min);\n    }\n    this.scrollActiveIntoView();\n  }\n\n  /** Jump to the last option. */\n  end(): void {\n    const opts = this.config.options();\n    if (!opts.length) return;\n    this.activeIndex.set(opts.length - 1);\n    this.scrollActiveIntoView();\n  }\n\n  /**\n   * Handle a keyboard event for listbox navigation.\n   *\n   * @returns `true` if the event was handled, `false` if the caller should\n   *   handle it (e.g. for typeahead or open/close toggling).\n   */\n  handleKeydown(\n    event: KeyboardEvent,\n    callbacks: {\n      onSelect?: (index: number) => void;\n      onOpen?: () => void;\n      onClose?: () => void;\n      isOpen?: () => boolean;\n    } = {},\n  ): boolean {\n    const opts = this.config.options();\n    const isOpen = callbacks.isOpen?.() ?? true;\n\n    switch (event.key) {\n      case 'ArrowDown':\n        event.preventDefault();\n        if (!isOpen) {\n          callbacks.onOpen?.();\n        } else {\n          this.move(1);\n        }\n        return true;\n\n      case 'ArrowUp':\n        event.preventDefault();\n        if (isOpen) {\n          this.move(-1);\n        }\n        return true;\n\n      case 'Home':\n        if (isOpen && opts.length) {\n          event.preventDefault();\n          this.home();\n        }\n        return true;\n\n      case 'End':\n        if (isOpen && opts.length) {\n          event.preventDefault();\n          this.end();\n        }\n        return true;\n\n      case 'Enter':\n      case ' ':\n      case 'Spacebar':\n        if (isOpen) {\n          event.preventDefault();\n          const idx = this.activeIndex();\n          if (idx >= 0 && opts[idx]) {\n            callbacks.onSelect?.(idx);\n          }\n        }\n        return true;\n\n      case 'Escape':\n        if (isOpen) {\n          event.preventDefault();\n          callbacks.onClose?.();\n        }\n        return true;\n\n      default:\n        return false;\n    }\n  }\n}\n"]}

package/esm2022/listbox-keyboard/ngxsmk-cdk-listbox-keyboard.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4c21rLWNkay1saXN0Ym94LWtleWJvYXJkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY2RrL2xpc3Rib3gta2V5Ym9hcmQvbmd4c21rLWNkay1saXN0Ym94LWtleWJvYXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19