structra-ui 0.1.4 → 0.1.5

package/esm2022/app/fields/dropdown-fields/_base/dropdown-option-field.base.mjs

@@ -0,0 +1,149 @@
+import { Directive, Input, booleanAttribute } from '@angular/core';
+import { NgControlFieldDirective } from '../../input-fields/_base/ng-control-field.directive';
+import * as i0 from "@angular/core";
+/**
+ * Lógica comum de select / combobox: opções, índice ativo, comparação e
+ * `notifyTouched` após seleção (evita flicker vermelho → válido no frame em que o valor ainda não atualizou o `FormControl`).
+ */
+export class DropdownOptionFieldBase extends NgControlFieldDirective {
+    constructor() {
+        super(...arguments);
+        /** Estado “tem valor” para o label flutuante (evita getter no template). */
+        this.filledUi = false;
+        this._options = [];
+        this._compareWith = Object.is;
+        /** Lista de opções ainda a carregar (painel aberto ou primeiro fetch). */
+        this.optionsLoading = false;
+        this.activeIndex = 0;
+    }
+    get options() {
+        return this._options;
+    }
+    set options(value) {
+        this._options = value ?? [];
+    }
+    /** Alias de {@link options}. */
+    set itemsInput(value) {
+        this._options = value ?? [];
+    }
+    get compareWith() {
+        return this._compareWith;
+    }
+    set compareWith(fn) {
+        this._compareWith = fn ?? Object.is;
+    }
+    /** Alias de {@link compareWith}. */
+    set compareBy(fn) {
+        this._compareWith = fn ?? Object.is;
+    }
+    refreshFilledUi() {
+        const v = this.internalValue;
+        this.filledUi = v != null && v !== '';
+    }
+    writeValue(value) {
+        super.writeValue(value);
+        this.refreshFilledUi();
+    }
+    emitModelValue(value) {
+        super.emitModelValue(value);
+        this.refreshFilledUi();
+    }
+    /**
+     * Opções na ordem de exibição no painel: valor atual (se existir em `options`) em primeiro lugar.
+     */
+    get listOptions() {
+        const src = this._options;
+        if (src.length === 0) {
+            return src;
+        }
+        const iv = this.internalValue;
+        if (iv == null || iv === '') {
+            return src;
+        }
+        const idx = src.findIndex((o) => !o.disabled && this.matches(o.value, iv));
+        if (idx <= 0) {
+            return src;
+        }
+        const selected = src[idx];
+        const rest = src.filter((_, i) => i !== idx);
+        return [selected, ...rest];
+    }
+    /**
+     * Chamar após `emitModelValue` + fechar painel ao **escolher** um item.
+     * Adia `notifyTouched` para o próximo microtask para o validador já ver o valor novo.
+     */
+    finishSelectionTouch() {
+        queueMicrotask(() => {
+            this.notifyTouched();
+            this.cdr.markForCheck();
+        });
+    }
+    trackOption(_index, opt) {
+        return opt.value;
+    }
+    isSelected(opt) {
+        return this.matches(opt.value, this.internalValue);
+    }
+    findOptionByValue(value) {
+        if (value == null) {
+            return undefined;
+        }
+        return this._options.find((o) => !o.disabled && this.matches(o.value, value));
+    }
+    matches(a, b) {
+        return this._compareWith(a, b);
+    }
+    syncActiveIndexFromValue(value) {
+        const list = this.listOptions;
+        const idx = list.findIndex((o) => !o.disabled && this.matches(o.value, value));
+        this.activeIndex = idx >= 0 ? idx : this.firstEnabledIndex();
+    }
+    firstEnabledIndex() {
+        const list = this.listOptions;
+        const i = list.findIndex((o) => !o.disabled);
+        return i >= 0 ? i : 0;
+    }
+    lastEnabledIndex() {
+        const list = this.listOptions;
+        for (let i = list.length - 1; i >= 0; i--) {
+            if (!list[i].disabled) {
+                return i;
+            }
+        }
+        return 0;
+    }
+    stepActive(delta) {
+        let i = this.activeIndex;
+        const list = this.listOptions;
+        const n = list.length;
+        if (n === 0) {
+            return 0;
+        }
+        for (let step = 0; step < n; step++) {
+            i = (i + delta + n) % n;
+            if (!list[i].disabled) {
+                return i;
+            }
+        }
+        return this.activeIndex;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownOptionFieldBase, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "17.3.12", type: DropdownOptionFieldBase, inputs: { options: "options", itemsInput: ["items", "itemsInput"], compareWith: "compareWith", compareBy: "compareBy", optionsLoading: ["optionsLoading", "optionsLoading", booleanAttribute] }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DropdownOptionFieldBase, decorators: [{
+            type: Directive
+        }], propDecorators: { options: [{
+                type: Input
+            }], itemsInput: [{
+                type: Input,
+                args: ['items']
+            }], compareWith: [{
+                type: Input
+            }], compareBy: [{
+                type: Input,
+                args: ['compareBy']
+            }], optionsLoading: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown-option-field.base.js","sourceRoot":"","sources":["../../../../../../../src/app/fields/dropdown-fields/_base/dropdown-option-field.base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, booleanAttribute } from '@angular/core';\r\nimport { NgControlFieldDirective } from '../../input-fields/_base/ng-control-field.directive';\r\nimport { UiSelectOption } from '../_models/select-option.model';\r\n\r\n/**\r\n * Lógica comum de select / combobox: opções, índice ativo, comparação e\r\n * `notifyTouched` após seleção (evita flicker vermelho → válido no frame em que o valor ainda não atualizou o `FormControl`).\r\n */\r\n@Directive()\r\nexport abstract class DropdownOptionFieldBase extends NgControlFieldDirective<unknown | null> {\r\n  /** Estado “tem valor” para o label flutuante (evita getter no template). */\r\n  filledUi = false;\r\n\r\n  private _options: ReadonlyArray<UiSelectOption<unknown>> = [];\r\n\r\n  @Input()\r\n  get options(): ReadonlyArray<UiSelectOption<unknown>> {\r\n    return this._options;\r\n  }\r\n  set options(value: ReadonlyArray<UiSelectOption<unknown>>) {\r\n    this._options = value ?? [];\r\n  }\r\n\r\n  /** Alias de {@link options}. */\r\n  @Input('items')\r\n  set itemsInput(value: ReadonlyArray<UiSelectOption<unknown>>) {\r\n    this._options = value ?? [];\r\n  }\r\n\r\n  private _compareWith: (a: unknown, b: unknown) => boolean = Object.is;\r\n\r\n  @Input()\r\n  get compareWith(): (a: unknown, b: unknown) => boolean {\r\n    return this._compareWith;\r\n  }\r\n  set compareWith(fn: (a: unknown, b: unknown) => boolean) {\r\n    this._compareWith = fn ?? Object.is;\r\n  }\r\n\r\n  /** Alias de {@link compareWith}. */\r\n  @Input('compareBy')\r\n  set compareBy(fn: (a: unknown, b: unknown) => boolean) {\r\n    this._compareWith = fn ?? Object.is;\r\n  }\r\n\r\n  /** Lista de opções ainda a carregar (painel aberto ou primeiro fetch). */\r\n  @Input({ transform: booleanAttribute }) optionsLoading = false;\r\n\r\n  activeIndex = 0;\r\n\r\n  protected refreshFilledUi(): void {\r\n    const v = this.internalValue;\r\n    this.filledUi = v != null && v !== '';\r\n  }\r\n\r\n  override writeValue(value: unknown | null): void {\r\n    super.writeValue(value);\r\n    this.refreshFilledUi();\r\n  }\r\n\r\n  protected override emitModelValue(value: unknown | null): void {\r\n    super.emitModelValue(value);\r\n    this.refreshFilledUi();\r\n  }\r\n\r\n  /**\r\n   * Opções na ordem de exibição no painel: valor atual (se existir em `options`) em primeiro lugar.\r\n   */\r\n  get listOptions(): ReadonlyArray<UiSelectOption<unknown>> {\r\n    const src = this._options;\r\n    if (src.length === 0) {\r\n      return src;\r\n    }\r\n    const iv = this.internalValue;\r\n    if (iv == null || iv === '') {\r\n      return src;\r\n    }\r\n    const idx = src.findIndex(\r\n      (o) => !o.disabled && this.matches(o.value, iv),\r\n    );\r\n    if (idx <= 0) {\r\n      return src;\r\n    }\r\n    const selected = src[idx];\r\n    const rest = src.filter((_, i) => i !== idx);\r\n    return [selected, ...rest];\r\n  }\r\n\r\n  /**\r\n   * Chamar após `emitModelValue` + fechar painel ao **escolher** um item.\r\n   * Adia `notifyTouched` para o próximo microtask para o validador já ver o valor novo.\r\n   */\r\n  protected finishSelectionTouch(): void {\r\n    queueMicrotask(() => {\r\n      this.notifyTouched();\r\n      this.cdr.markForCheck();\r\n    });\r\n  }\r\n\r\n  trackOption(_index: number, opt: UiSelectOption<unknown>): unknown {\r\n    return opt.value;\r\n  }\r\n\r\n  isSelected(opt: UiSelectOption<unknown>): boolean {\r\n    return this.matches(opt.value, this.internalValue);\r\n  }\r\n\r\n  protected findOptionByValue(\r\n    value: unknown | null,\r\n  ): UiSelectOption<unknown> | undefined {\r\n    if (value == null) {\r\n      return undefined;\r\n    }\r\n    return this._options.find(\r\n      (o) => !o.disabled && this.matches(o.value, value),\r\n    );\r\n  }\r\n\r\n  protected matches(a: unknown, b: unknown): boolean {\r\n    return this._compareWith(a, b);\r\n  }\r\n\r\n  protected syncActiveIndexFromValue(value: unknown | null): void {\r\n    const list = this.listOptions;\r\n    const idx = list.findIndex(\r\n      (o) => !o.disabled && this.matches(o.value, value),\r\n    );\r\n    this.activeIndex = idx >= 0 ? idx : this.firstEnabledIndex();\r\n  }\r\n\r\n  protected firstEnabledIndex(): number {\r\n    const list = this.listOptions;\r\n    const i = list.findIndex((o) => !o.disabled);\r\n    return i >= 0 ? i : 0;\r\n  }\r\n\r\n  protected lastEnabledIndex(): number {\r\n    const list = this.listOptions;\r\n    for (let i = list.length - 1; i >= 0; i--) {\r\n      if (!list[i].disabled) {\r\n        return i;\r\n      }\r\n    }\r\n    return 0;\r\n  }\r\n\r\n  protected stepActive(delta: number): number {\r\n    let i = this.activeIndex;\r\n    const list = this.listOptions;\r\n    const n = list.length;\r\n    if (n === 0) {\r\n      return 0;\r\n    }\r\n    for (let step = 0; step < n; step++) {\r\n      i = (i + delta + n) % n;\r\n      if (!list[i].disabled) {\r\n        return i;\r\n      }\r\n    }\r\n    return this.activeIndex;\r\n  }\r\n}\r\n"]}

package/esm2022/app/fields/dropdown-fields/_base/dropdown-trigger-blur.util.mjs

@@ -0,0 +1,32 @@
+/**
+ * Após `blur` no trigger ou na lista: se o painel está aberto e o foco não ficou
+ * dentro da **origem do overlay** (valor + chevron / input; não o botão limpar do `base-field`)
+ * nem no overlay CDK, fecha o painel.
+ */
+export function scheduleCloseDropdownPanelOnTriggerBlur(options) {
+    setTimeout(() => {
+        const rt = options.blurRelatedTarget;
+        if (rt && typeof rt.closest === 'function') {
+            if (options.triggerRoot.contains(rt) || rt.closest('.cdk-overlay-container')) {
+                options.notifyTouched();
+                options.afterBlur?.();
+                return;
+            }
+        }
+        const a = document.activeElement;
+        if (a && options.triggerRoot.contains(a)) {
+            return;
+        }
+        if (a && typeof a.closest === 'function') {
+            if (a.closest('.cdk-overlay-container')) {
+                return;
+            }
+        }
+        if (options.isPanelOpen()) {
+            options.closePanel();
+        }
+        options.notifyTouched();
+        options.afterBlur?.();
+    }, 0);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/fields/dropdown-fields/_models/dropdown-list-bindings.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24tbGlzdC1iaW5kaW5ncy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvZmllbGRzL2Ryb3Bkb3duLWZpZWxkcy9fbW9kZWxzL2Ryb3Bkb3duLWxpc3QtYmluZGluZ3MubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgVWlTZWxlY3RPcHRpb24gfSBmcm9tICcuL3NlbGVjdC1vcHRpb24ubW9kZWwnO1xyXG5cclxuLyoqXHJcbiAqIENvbnRyYXRvIGRvY3VtZW50YWwgcGFyYSBjYW1wb3MgY29tIGxpc3RhIGRlIG9ww6fDtWVzIChgc2VsZWN0YCwgYG11bHRpc2VsZWN0YCwgYGRyb3Bkb3duLXNlYXJjaGApLlxyXG4gKlxyXG4gKiAqKkNhbsOzbmljb3MgLyBhbGlhc2VzKipcclxuICogLSBgb3B0aW9uc2AgfCBgaXRlbXNgIOKAlCBtZXNtYSBsaXN0YVxyXG4gKiAtIGBjb21wYXJlV2l0aGAgfCBgY29tcGFyZUJ5YCDigJQgbWVzbWEgZnVuw6fDo29cclxuICogLSBgcGFnaW5hdGlvbmAgfCBgcGFnZWFibGVgIOKAlCBzw7MgZW0gYHNlbGVjdGAgZSBgbXVsdGlzZWxlY3RgXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIERyb3Bkb3duTGlzdEJpbmRpbmdzPFQgPSB1bmtub3duPiB7XHJcbiAgb3B0aW9uczogUmVhZG9ubHlBcnJheTxVaVNlbGVjdE9wdGlvbjxUPj47XHJcbiAgY29tcGFyZVdpdGg6IChhOiB1bmtub3duLCBiOiB1bmtub3duKSA9PiBib29sZWFuO1xyXG59XHJcbiJdfQ==

package/esm2022/app/fields/dropdown-fields/_models/dropdown-search-page-requested.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24tc2VhcmNoLXBhZ2UtcmVxdWVzdGVkLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9maWVsZHMvZHJvcGRvd24tZmllbGRzL19tb2RlbHMvZHJvcGRvd24tc2VhcmNoLXBhZ2UtcmVxdWVzdGVkLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogUGVkaWRvIGRlIHDDoWdpbmEgcGFyYSBvIGNhbXBvIGNvbSBidXNjYSArIHNjcm9sbCBpbmZpbml0by4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBEcm9wZG93blNlYXJjaFBhZ2VSZXF1ZXN0ZWQge1xyXG4gIHBhZ2U6IG51bWJlcjtcclxuICBwYWdlU2l6ZTogbnVtYmVyO1xyXG4gIC8qKiBGaWx0cm8gYXR1YWwgKGFww7NzIEVudGVyKS4gVmF6aW8gPSBsaXN0YXIgdHVkbyBwYWdpbmFkby4gKi9cclxuICBxdWVyeTogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2022/app/fields/dropdown-fields/_models/index.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2ZpZWxkcy9kcm9wZG93bi1maWVsZHMvX21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgeyBVaVNlbGVjdE9wdGlvbiB9IGZyb20gJy4vc2VsZWN0LW9wdGlvbi5tb2RlbCc7XHJcbmV4cG9ydCB0eXBlIHsgU2VsZWN0UGFnZVJlcXVlc3RlZCB9IGZyb20gJy4vc2VsZWN0LXBhZ2luYXRpb24ubW9kZWwnO1xyXG5leHBvcnQgdHlwZSB7IERyb3Bkb3duU2VhcmNoUGFnZVJlcXVlc3RlZCB9IGZyb20gJy4vZHJvcGRvd24tc2VhcmNoLXBhZ2UtcmVxdWVzdGVkLm1vZGVsJztcclxuZXhwb3J0IHR5cGUgeyBEcm9wZG93bkxpc3RCaW5kaW5ncyB9IGZyb20gJy4vZHJvcGRvd24tbGlzdC1iaW5kaW5ncy5tb2RlbCc7XHJcbiJdfQ==

package/esm2022/app/fields/dropdown-fields/_models/select-option.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LW9wdGlvbi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvZmllbGRzL2Ryb3Bkb3duLWZpZWxkcy9fbW9kZWxzL3NlbGVjdC1vcHRpb24ubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgVWlTZWxlY3RPcHRpb248VCA9IHVua25vd24+IHtcclxuICBsYWJlbDogc3RyaW5nO1xyXG4gIHZhbHVlOiBUO1xyXG4gIGRpc2FibGVkPzogYm9vbGVhbjtcclxufVxyXG4iXX0=

package/esm2022/app/fields/dropdown-fields/_models/select-pagination.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LXBhZ2luYXRpb24ubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2ZpZWxkcy9kcm9wZG93bi1maWVsZHMvX21vZGVscy9zZWxlY3QtcGFnaW5hdGlvbi5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIEV2ZW50byBlbWl0aWRvIHBlbG8gc2VsZWN0IHBhZ2luYWRvIGFvIHByZWNpc2FyIGRlIG1haXMgZGFkb3MgKGV4LjogYmFja2VuZCAvIGNvbWJvYm94KS4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBTZWxlY3RQYWdlUmVxdWVzdGVkIHtcclxuICAvKiogUMOhZ2luYSAwLWJhc2VkICgwID0gcHJpbWVpcm9zIGBwYWdlU2l6ZWAgaXRlbnMpLiAqL1xyXG4gIHBhZ2U6IG51bWJlcjtcclxuICBwYWdlU2l6ZTogbnVtYmVyO1xyXG59XHJcbiJdfQ==