asksuite-citrus 3.20.5 → 3.20.7

package/esm2022/lib/components/select-v2/base-multi-select.mjs

@@ -22,6 +22,37 @@ export function computeOverflow(values, threshold) {
     }
     return { visible: values.slice(0, threshold), overflowCount: values.length - threshold };
 }
+/** Keep in sync with `gap: 4px` on `__tag-group` in select-v2 / combobox-v2 scss. */
+export const CHIP_GAP_PX = 4;
+/**
+ * Fits as many chips as possible in `containerWidth` (greedy, in order).
+ * - When ALL chips fit, no space is reserved for the `+N` chip.
+ * - Otherwise reserves `plusNWidth` and packs chips until the next one wouldn't fit.
+ * - Always keeps at least 1 chip visible — when even `chip[0] + gap + plusN` doesn't
+ *   fit, CSS degrades gracefully (the chip ellipsizes, the group clips overflow).
+ */
+export function computeWidthOverflow(chipWidths, containerWidth, gap, plusNWidth) {
+    const total = chipWidths.length;
+    if (total === 0) {
+        return { visibleCount: 0, overflowCount: 0 };
+    }
+    const sumAll = chipWidths.reduce((s, w) => s + w, 0) + gap * (total - 1);
+    if (sumAll <= containerWidth) {
+        return { visibleCount: total, overflowCount: 0 };
+    }
+    // Overflow row is [chip, ..., +N] → used = plusN + Σ(gap + chip) per visible chip.
+    let used = plusNWidth;
+    let visibleCount = 0;
+    for (const w of chipWidths) {
+        if (used + gap + w > containerWidth) {
+            break;
+        }
+        used += gap + w;
+        visibleCount++;
+    }
+    visibleCount = Math.max(visibleCount, 1);
+    return { visibleCount, overflowCount: total - visibleCount };
+}
 /** Normalizes the value coming from `writeValue`/`@Input value` into an internal array. */
 export function rehydrate(raw, multiple) {
     if (multiple) {
@@ -33,4 +64,4 @@ export function rehydrate(raw, multiple) {
 export function toModel(values, multiple) {
     return multiple ? [...values] : values[0] ?? null;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/select-v2/chip-overflow-measurer.mjs

@@ -0,0 +1,62 @@
+import { CHIP_GAP_PX, computeWidthOverflow } from './base-multi-select';
+/**
+ * Shared by `ask-select-v2` and `ask-combobox-v2`: watches the trigger width and
+ * recomputes how many chips fit, outside the Angular zone. Re-enters the zone only
+ * when the fitted count actually changes — this keeps ResizeObserver/rAF callbacks
+ * from churning change detection or creating measure→render→measure loops.
+ */
+export class ChipOverflowMeasurer {
+    constructor(zone, 
+    /** Reads the DOM. Return null when there's nothing to measure (e.g. single mode). */
+    read, 
+    /** Called inside the zone, only when the fitted count changes. */
+    apply) {
+        this.zone = zone;
+        this.read = read;
+        this.apply = apply;
+        this.rafId = null;
+        this.lastApplied = null;
+    }
+    observe(container) {
+        if (typeof ResizeObserver === 'undefined') {
+            return;
+        }
+        this.zone.runOutsideAngular(() => {
+            this.resizeObserver = new ResizeObserver(() => this.schedule());
+            this.resizeObserver.observe(container);
+        });
+    }
+    /** rAF-debounced so a selection change + resize coalesce into one measurement. */
+    schedule() {
+        if (this.rafId !== null || typeof requestAnimationFrame === 'undefined') {
+            return;
+        }
+        this.zone.runOutsideAngular(() => {
+            this.rafId = requestAnimationFrame(() => {
+                this.rafId = null;
+                this.measureNow();
+            });
+        });
+    }
+    measureNow() {
+        const m = this.read();
+        // Hidden or not rendered (width 0): keep the last applied value.
+        if (!m || m.containerWidth <= 0) {
+            return;
+        }
+        const { visibleCount } = computeWidthOverflow(m.chipWidths, m.containerWidth, CHIP_GAP_PX, m.plusNWidth);
+        if (visibleCount === this.lastApplied) {
+            return;
+        }
+        this.lastApplied = visibleCount;
+        this.zone.run(() => this.apply(visibleCount));
+    }
+    destroy() {
+        this.resizeObserver?.disconnect();
+        if (this.rafId !== null && typeof cancelAnimationFrame !== 'undefined') {
+            cancelAnimationFrame(this.rafId);
+        }
+        this.rafId = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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