@lucca-front/ng 7.4.0 → 8.0.0

package/esm2020/option/lib/picker/option-picker.model.mjs

@@ -0,0 +1,69 @@
+import { ESCAPE, TAB } from '@angular/cdk/keycodes';
+import { ALuPickerPanel } from '@lucca-front/ng/picker';
+import { merge, Subscription } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+export class ALuOptionPicker extends ALuPickerPanel {
+    constructor() {
+        super(...arguments);
+        this._subs = new Subscription();
+        this.optionComparer = (option1, option2) => JSON.stringify(option1) === JSON.stringify(option2);
+    }
+    setValue(value) {
+        this._value = value;
+        this._applySelected();
+    }
+    get _options$() { return this.__options$; }
+    set _options$(options$) {
+        this.__options$ = options$;
+        // reapply selected when the options change
+        this._subs.add(options$
+            .subscribe(o => {
+            this._applySelected();
+            this._applyHighlight();
+        }));
+        // subscribe to any option.onSelect
+        const singleFlow$ = options$.pipe(switchMap(items => merge(...items.map(i => i.onSelect))));
+        this._subs.add(singleFlow$.subscribe(option => this._toggle(option)));
+    }
+    _toggle(option) {
+        const value = option.value;
+        if (!this.multiple) {
+            this._select(value);
+        }
+        else {
+            const values = this._value || [];
+            let newValues;
+            if (values.some(v => this.optionComparer(v, value))) {
+                // value was present, we remove it
+                newValues = values.filter(v => !this.optionComparer(v, value));
+            }
+            else {
+                // value was absent, we add it
+                newValues = [...values, value];
+            }
+            this._select(newValues);
+        }
+    }
+    _select(val) {
+        this._emitSelectValue(val);
+        if (!this.multiple) {
+            this._emitCloseEvent();
+        }
+    }
+    destroy() {
+        this._subs.unsubscribe();
+    }
+    _handleKeydown(event) {
+        switch (event.keyCode) {
+            case ESCAPE:
+                this._emitCloseEvent();
+                event.preventDefault();
+                event.stopPropagation();
+                break;
+            case TAB:
+                this._emitCloseEvent();
+                break;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLXBpY2tlci5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL29wdGlvbi9zcmMvbGliL3BpY2tlci9vcHRpb24tcGlja2VyLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGNBQWMsRUFBa0IsTUFBTSx3QkFBd0IsQ0FBQztBQUN4RSxPQUFPLEVBQUUsS0FBSyxFQUFjLFlBQVksRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN2RCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFPM0MsTUFBTSxPQUFnQixlQUF3RSxTQUFRLGNBQWlCO0lBQXZIOztRQUNXLFVBQUssR0FBRyxJQUFJLFlBQVksRUFBRSxDQUFDO1FBMkIzQixtQkFBYyxHQUN2QixDQUFDLE9BQVUsRUFBRSxPQUFVLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLEtBQUssSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQTtJQTRDakYsQ0FBQztJQXJFQSxRQUFRLENBQUMsS0FBYztRQUN0QixJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssQ0FBQztRQUNwQixJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7SUFDdkIsQ0FBQztJQUVELElBQWMsU0FBUyxLQUFLLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7SUFDckQsSUFBYyxTQUFTLENBQUMsUUFBeUI7UUFDaEQsSUFBSSxDQUFDLFVBQVUsR0FBRyxRQUFRLENBQUM7UUFDM0IsMkNBQTJDO1FBQzNDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUNiLFFBQVE7YUFDTixTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUU7WUFDZCxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7WUFDdEIsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQ3hCLENBQUMsQ0FBQyxDQUNILENBQUM7UUFDRixtQ0FBbUM7UUFDbkMsTUFBTSxXQUFXLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQzFDLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUM3QyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FDYixXQUFXLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUNyRCxDQUFDO0lBQ0gsQ0FBQztJQUdTLE9BQU8sQ0FBQyxNQUFTO1FBQzFCLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUM7UUFDM0IsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDbkIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztTQUNwQjthQUFNO1lBQ04sTUFBTSxNQUFNLEdBQVEsSUFBSSxDQUFDLE1BQU0sSUFBSSxFQUFFLENBQUM7WUFDdEMsSUFBSSxTQUFTLENBQUM7WUFDZCxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQyxFQUFFO2dCQUNwRCxrQ0FBa0M7Z0JBQ2xDLFNBQVMsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDO2FBQy9EO2lCQUFNO2dCQUNOLDhCQUE4QjtnQkFDOUIsU0FBUyxHQUFHLENBQUMsR0FBRyxNQUFNLEVBQUUsS0FBSyxDQUFDLENBQUM7YUFDL0I7WUFDRCxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1NBQ3hCO0lBQ0YsQ0FBQztJQUVTLE9BQU8sQ0FBQyxHQUFZO1FBQzdCLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUMzQixJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRTtZQUNuQixJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7U0FDdkI7SUFDRixDQUFDO0lBR1MsT0FBTztRQUNoQixJQUFJLENBQUMsS0FBSyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQzFCLENBQUM7SUFDUSxjQUFjLENBQUMsS0FBb0I7UUFDM0MsUUFBUSxLQUFLLENBQUMsT0FBTyxFQUFFO1lBQ3RCLEtBQUssTUFBTTtnQkFDVixJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7Z0JBQ3ZCLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztnQkFDdkIsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO2dCQUN4QixNQUFNO1lBQ1AsS0FBSyxHQUFHO2dCQUNQLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztnQkFDdkIsTUFBTTtTQUNQO0lBQ0YsQ0FBQztDQUdEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRVNDQVBFLCBUQUIgfSBmcm9tICdAYW5ndWxhci9jZGsva2V5Y29kZXMnO1xyXG5pbXBvcnQgeyBBTHVQaWNrZXJQYW5lbCwgSUx1UGlja2VyUGFuZWwgfSBmcm9tICdAbHVjY2EtZnJvbnQvbmcvcGlja2VyJztcclxuaW1wb3J0IHsgbWVyZ2UsIE9ic2VydmFibGUsIFN1YnNjcmlwdGlvbiB9IGZyb20gJ3J4anMnO1xyXG5pbXBvcnQgeyBzd2l0Y2hNYXAgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XHJcbmltcG9ydCB7IElMdU9wdGlvbkl0ZW0gfSBmcm9tICcuLi9pdGVtL29wdGlvbi1pdGVtLm1vZGVsJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSUx1T3B0aW9uUGlja2VyUGFuZWw8VCA9IGFueT4gZXh0ZW5kcyBJTHVQaWNrZXJQYW5lbDxUPiB7IH1cclxuXHJcbmV4cG9ydCB0eXBlIEx1T3B0aW9uQ29tcGFyZXI8VD4gPSAob3B0aW9uMTogVCwgb3B0aW9uMjogVCkgPT4gYm9vbGVhbjtcclxuXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBTHVPcHRpb25QaWNrZXI8VCA9IGFueSwgTyBleHRlbmRzIElMdU9wdGlvbkl0ZW08VD4gPSBJTHVPcHRpb25JdGVtPFQ+PiBleHRlbmRzIEFMdVBpY2tlclBhbmVsPFQ+IGltcGxlbWVudHMgSUx1T3B0aW9uUGlja2VyUGFuZWw8VD4ge1xyXG5cdHByb3RlY3RlZCBfc3VicyA9IG5ldyBTdWJzY3JpcHRpb24oKTtcclxuXHRvdmVycmlkZSBvblNlbGVjdFZhbHVlOiBPYnNlcnZhYmxlPFQgfCBUW10+O1xyXG5cdHByb3RlY3RlZCBfdmFsdWU6IFQgfCBUW107XHJcblx0c2V0VmFsdWUodmFsdWU6IFQgfCBUW10pIHtcclxuXHRcdHRoaXMuX3ZhbHVlID0gdmFsdWU7XHJcblx0XHR0aGlzLl9hcHBseVNlbGVjdGVkKCk7XHJcblx0fVxyXG5cdHByaXZhdGUgX19vcHRpb25zJDogT2JzZXJ2YWJsZTxPW10+O1xyXG5cdHByb3RlY3RlZCBnZXQgX29wdGlvbnMkKCkgeyByZXR1cm4gdGhpcy5fX29wdGlvbnMkOyB9XHJcblx0cHJvdGVjdGVkIHNldCBfb3B0aW9ucyQob3B0aW9ucyQ6IE9ic2VydmFibGU8T1tdPikge1xyXG5cdFx0dGhpcy5fX29wdGlvbnMkID0gb3B0aW9ucyQ7XHJcblx0XHQvLyByZWFwcGx5IHNlbGVjdGVkIHdoZW4gdGhlIG9wdGlvbnMgY2hhbmdlXHJcblx0XHR0aGlzLl9zdWJzLmFkZChcclxuXHRcdFx0b3B0aW9ucyRcclxuXHRcdFx0XHQuc3Vic2NyaWJlKG8gPT4ge1xyXG5cdFx0XHRcdFx0dGhpcy5fYXBwbHlTZWxlY3RlZCgpO1xyXG5cdFx0XHRcdFx0dGhpcy5fYXBwbHlIaWdobGlnaHQoKTtcclxuXHRcdFx0XHR9KVxyXG5cdFx0KTtcclxuXHRcdC8vIHN1YnNjcmliZSB0byBhbnkgb3B0aW9uLm9uU2VsZWN0XHJcblx0XHRjb25zdCBzaW5nbGVGbG93JCA9IG9wdGlvbnMkLnBpcGUoc3dpdGNoTWFwKFxyXG5cdFx0XHRpdGVtcyA9PiBtZXJnZSguLi5pdGVtcy5tYXAoaSA9PiBpLm9uU2VsZWN0KSlcclxuXHRcdCkpO1xyXG5cdFx0dGhpcy5fc3Vicy5hZGQoXHJcblx0XHRcdHNpbmdsZUZsb3ckLnN1YnNjcmliZShvcHRpb24gPT4gdGhpcy5fdG9nZ2xlKG9wdGlvbikpXHJcblx0XHQpO1xyXG5cdH1cclxuXHRwcm90ZWN0ZWQgb3B0aW9uQ29tcGFyZXI6IEx1T3B0aW9uQ29tcGFyZXI8VD4gPVxyXG5cdFx0KG9wdGlvbjE6IFQsIG9wdGlvbjI6IFQpID0+IEpTT04uc3RyaW5naWZ5KG9wdGlvbjEpID09PSBKU09OLnN0cmluZ2lmeShvcHRpb24yKVxyXG5cdHByb3RlY3RlZCBfdG9nZ2xlKG9wdGlvbjogTykge1xyXG5cdFx0Y29uc3QgdmFsdWUgPSBvcHRpb24udmFsdWU7XHJcblx0XHRpZiAoIXRoaXMubXVsdGlwbGUpIHtcclxuXHRcdFx0dGhpcy5fc2VsZWN0KHZhbHVlKTtcclxuXHRcdH0gZWxzZSB7XHJcblx0XHRcdGNvbnN0IHZhbHVlcyA9IDxUW10+dGhpcy5fdmFsdWUgfHwgW107XHJcblx0XHRcdGxldCBuZXdWYWx1ZXM7XHJcblx0XHRcdGlmICh2YWx1ZXMuc29tZSh2ID0+IHRoaXMub3B0aW9uQ29tcGFyZXIodiwgdmFsdWUpKSkge1xyXG5cdFx0XHRcdC8vIHZhbHVlIHdhcyBwcmVzZW50LCB3ZSByZW1vdmUgaXRcclxuXHRcdFx0XHRuZXdWYWx1ZXMgPSB2YWx1ZXMuZmlsdGVyKHYgPT4gIXRoaXMub3B0aW9uQ29tcGFyZXIodiwgdmFsdWUpKTtcclxuXHRcdFx0fSBlbHNlIHtcclxuXHRcdFx0XHQvLyB2YWx1ZSB3YXMgYWJzZW50LCB3ZSBhZGQgaXRcclxuXHRcdFx0XHRuZXdWYWx1ZXMgPSBbLi4udmFsdWVzLCB2YWx1ZV07XHJcblx0XHRcdH1cclxuXHRcdFx0dGhpcy5fc2VsZWN0KG5ld1ZhbHVlcyk7XHJcblx0XHR9XHJcblx0fVxyXG5cclxuXHRwcm90ZWN0ZWQgX3NlbGVjdCh2YWw6IFQgfCBUW10pIHtcclxuXHRcdHRoaXMuX2VtaXRTZWxlY3RWYWx1ZSh2YWwpO1xyXG5cdFx0aWYgKCF0aGlzLm11bHRpcGxlKSB7XHJcblx0XHRcdHRoaXMuX2VtaXRDbG9zZUV2ZW50KCk7XHJcblx0XHR9XHJcblx0fVxyXG5cdHByb3RlY3RlZCBhYnN0cmFjdCBfYXBwbHlTZWxlY3RlZCgpO1xyXG5cdHByb3RlY3RlZCBhYnN0cmFjdCBfYXBwbHlIaWdobGlnaHQoKTtcclxuXHRwcm90ZWN0ZWQgZGVzdHJveSgpIHtcclxuXHRcdHRoaXMuX3N1YnMudW5zdWJzY3JpYmUoKTtcclxuXHR9XHJcblx0b3ZlcnJpZGUgX2hhbmRsZUtleWRvd24oZXZlbnQ6IEtleWJvYXJkRXZlbnQpIHtcclxuXHRcdHN3aXRjaCAoZXZlbnQua2V5Q29kZSkge1xyXG5cdFx0XHRjYXNlIEVTQ0FQRTpcclxuXHRcdFx0XHR0aGlzLl9lbWl0Q2xvc2VFdmVudCgpO1xyXG5cdFx0XHRcdGV2ZW50LnByZXZlbnREZWZhdWx0KCk7XHJcblx0XHRcdFx0ZXZlbnQuc3RvcFByb3BhZ2F0aW9uKCk7XHJcblx0XHRcdFx0YnJlYWs7XHJcblx0XHRcdGNhc2UgVEFCOlxyXG5cdFx0XHRcdHRoaXMuX2VtaXRDbG9zZUV2ZW50KCk7XHJcblx0XHRcdFx0YnJlYWs7XHJcblx0XHR9XHJcblx0fVxyXG5cclxuXHRwcm90ZWN0ZWQgYWJzdHJhY3QgX2VtaXRTZWxlY3RWYWx1ZSh2YWx1ZTogVCB8IFRbXSk7XHJcbn1cclxuIl19

package/esm2020/option/lib/picker/option-picker.module.mjs

@@ -0,0 +1,49 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { LuScrollModule } from '@lucca-front/ng/scroll';
+import { LuOptionItemModule } from '../item/index';
+import { LuOptionPickerAdvancedComponent } from './option-picker-advanced.component';
+import { LuOptionPickerComponent } from './option-picker.component';
+import * as i0 from "@angular/core";
+export class LuOptionPickerModule {
+}
+LuOptionPickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LuOptionPickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerModule, declarations: [LuOptionPickerComponent,
+        LuOptionPickerAdvancedComponent], imports: [CommonModule,
+        OverlayModule,
+        LuOptionItemModule,
+        LuScrollModule,
+        A11yModule], exports: [LuOptionPickerComponent,
+        LuOptionPickerAdvancedComponent,
+        LuOptionItemModule] });
+LuOptionPickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerModule, imports: [[
+            CommonModule,
+            OverlayModule,
+            LuOptionItemModule,
+            LuScrollModule,
+            A11yModule,
+        ], LuOptionItemModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        OverlayModule,
+                        LuOptionItemModule,
+                        LuScrollModule,
+                        A11yModule,
+                    ],
+                    declarations: [
+                        LuOptionPickerComponent,
+                        LuOptionPickerAdvancedComponent,
+                    ],
+                    exports: [
+                        LuOptionPickerComponent,
+                        LuOptionPickerAdvancedComponent,
+                        LuOptionItemModule,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/option/lib/picker/tree-option-picker-advanced.component.mjs

@@ -0,0 +1,138 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, forwardRef, Directive, Inject, } from '@angular/core';
+import { luTransformPopover } from '@lucca-front/ng/popover';
+import { merge } from 'rxjs';
+import { first, mapTo, startWith, shareReplay, mergeAll } from 'rxjs/operators';
+import { ALuPickerPanel } from '@lucca-front/ng/picker';
+import { ALuTreeOptionOperator, } from '../operator/index';
+import { ALuTreeOptionPickerComponent } from './tree-option-picker.component';
+import { ALuOnOpenSubscriber, ALuOnCloseSubscriber, ALuOnScrollBottomSubscriber } from '@lucca-front/ng/core';
+import { ALuTreeOptionSelector } from '../selector/index';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@lucca-front/ng/scroll";
+import * as i3 from "@angular/cdk/a11y";
+export class ALuTreeOptionPickerAdvancedComponent extends ALuTreeOptionPickerComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+        this._operators = [];
+        this._onOpenSubscribers = [];
+        this._onCloseSubscribers = [];
+        this._onScrollBottomSubscribers = [];
+        this._selectors = [];
+    }
+    set operatorsQL(ql) {
+        this._operatorsQL = ql;
+    }
+    set onOpenSubsQL(ql) {
+        this._onOpenSubscribers = ql.toArray();
+    }
+    set onCloseSubsQL(ql) {
+        this._onCloseSubscribers = ql.toArray();
+    }
+    set onScrollBottomSubsQL(ql) {
+        this._onScrollBottomSubscribers = ql.toArray();
+    }
+    set selectorsQL(ql) {
+        this._selectorsQL = ql;
+    }
+    onScrollBottom() {
+        this._onScrollBottomSubscribers.forEach(o => {
+            if (!o.onScrollBottom) {
+                return;
+            }
+            o.onScrollBottom();
+        });
+    }
+    onOpen() {
+        this._onOpenSubscribers.forEach(o => {
+            o.onOpen();
+        });
+        super.onOpen();
+    }
+    onClose() {
+        this._onCloseSubscribers.forEach(o => {
+            o.onClose();
+        });
+        super.onClose();
+    }
+    setValue(value) {
+        super.setValue(value);
+        this._selectors.forEach(s => s.setValue(value));
+    }
+    initOperators() {
+        const operators = this._operatorsQL.toArray();
+        this._operators = operators;
+        let options$;
+        operators.forEach(operator => {
+            operator.inOptions$ = options$;
+            options$ = operator.outOptions$;
+        });
+        const lastOperator = operators[operators.length - 1];
+        if (lastOperator && lastOperator.outOptions$) {
+            this.loading$ = lastOperator.outOptions$.pipe(first(), mapTo(false), startWith(true), shareReplay());
+        }
+    }
+    initSelectors() {
+        this._selectors = this._selectorsQL.toArray();
+        this._subs.add(merge(this._selectors.map(s => s.onSelectValue)).pipe(mergeAll()).subscribe(values => {
+            this._select(values);
+        }));
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        this.initOperators();
+        this.initSelectors();
+    }
+}
+ALuTreeOptionPickerAdvancedComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuTreeOptionPickerAdvancedComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+ALuTreeOptionPickerAdvancedComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: ALuTreeOptionPickerAdvancedComponent, queries: [{ propertyName: "operatorsQL", predicate: ALuTreeOptionOperator, descendants: true }, { propertyName: "onOpenSubsQL", predicate: ALuOnOpenSubscriber, descendants: true }, { propertyName: "onCloseSubsQL", predicate: ALuOnCloseSubscriber, descendants: true }, { propertyName: "onScrollBottomSubsQL", predicate: ALuOnScrollBottomSubscriber, descendants: true }, { propertyName: "selectorsQL", predicate: ALuTreeOptionSelector, descendants: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuTreeOptionPickerAdvancedComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { operatorsQL: [{
+                type: ContentChildren,
+                args: [ALuTreeOptionOperator, { descendants: true }]
+            }], onOpenSubsQL: [{
+                type: ContentChildren,
+                args: [ALuOnOpenSubscriber, { descendants: true }]
+            }], onCloseSubsQL: [{
+                type: ContentChildren,
+                args: [ALuOnCloseSubscriber, { descendants: true }]
+            }], onScrollBottomSubsQL: [{
+                type: ContentChildren,
+                args: [ALuOnScrollBottomSubscriber, { descendants: true }]
+            }], selectorsQL: [{
+                type: ContentChildren,
+                args: [ALuTreeOptionSelector, { descendants: true }]
+            }] } });
+/**
+* advanced option picker panel
+*/
+export class LuTreeOptionPickerAdvancedComponent extends ALuTreeOptionPickerAdvancedComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+    }
+}
+LuTreeOptionPickerAdvancedComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerAdvancedComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+LuTreeOptionPickerAdvancedComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: LuTreeOptionPickerAdvancedComponent, selector: "lu-tree-option-picker-advanced", providers: [
+        {
+            provide: ALuPickerPanel,
+            useExisting: forwardRef(() => LuTreeOptionPickerAdvancedComponent),
+        },
+    ], exportAs: ["LuOptionPicker"], usesInheritance: true, ngImport: i0, template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-tree-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\" luScroll (onScrollBottom)=\"onScrollBottom()\">\r\n\t\t\t<ng-content [class.is-loading]=\"loading$ | async\"></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2.LuScrollDirective, selector: "[luScroll]", inputs: ["debounceTime"], outputs: ["onScroll", "onScrollTop", "onScrollBottom", "onScrollLeft", "onScrollRight"], exportAs: ["luScroll"] }, { type: i3.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }], animations: [luTransformPopover], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerAdvancedComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lu-tree-option-picker-advanced', changeDetection: ChangeDetectionStrategy.OnPush, animations: [luTransformPopover], exportAs: 'LuOptionPicker', providers: [
+                        {
+                            provide: ALuPickerPanel,
+                            useExisting: forwardRef(() => LuTreeOptionPickerAdvancedComponent),
+                        },
+                    ], template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-tree-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\" luScroll (onScrollBottom)=\"onScrollBottom()\">\r\n\t\t\t<ng-content [class.is-loading]=\"loading$ | async\"></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-option-picker-advanced.component.js","sourceRoot":"","sources":["../../../../../../packages/ng/option/src/lib/picker/tree-option-picker-advanced.component.ts","../../../../../../packages/ng/option/src/lib/picker/tree-option-picker-advanced.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n\tChangeDetectionStrategy,\r\n\tComponent,\r\n\tContentChildren,\r\n\tQueryList,\r\n\tforwardRef,\r\n\tChangeDetectorRef,\r\n\tAfterViewInit,\r\n\tDirective,\r\n\tInject,\r\n} from '@angular/core';\r\nimport { luTransformPopover } from '@lucca-front/ng/popover';\r\nimport { Observable, merge } from 'rxjs';\r\nimport { first, mapTo, startWith, shareReplay, delay, mergeAll } from 'rxjs/operators';\r\nimport { ALuPickerPanel } from '@lucca-front/ng/picker';\r\nimport {\r\n\tALuTreeOptionOperator,\r\n\tILuTreeOptionOperator,\r\n} from '../operator/index';\r\nimport { ALuTreeOptionPickerComponent } from './tree-option-picker.component';\r\nimport { ILuTree } from '@lucca-front/ng/core';\r\nimport {\r\n\tALuOnOpenSubscriber,\r\n\tILuOnOpenSubscriber,\r\n\tALuOnCloseSubscriber,\r\n\tILuOnCloseSubscriber,\r\n\tILuOnScrollBottomSubscriber,\r\n\tALuOnScrollBottomSubscriber\r\n} from '@lucca-front/ng/core';\r\nimport { ILuTreeOptionSelector, ALuTreeOptionSelector } from '../selector/index';\r\nimport { DOCUMENT } from '@angular/common';\r\n\r\n@Directive()\r\nexport abstract class ALuTreeOptionPickerAdvancedComponent<T = any, O extends import('../item/tree-option-item.model').ILuTreeOptionItem<T> = import('../item/tree-option-item.model').ILuTreeOptionItem<T>>\r\nextends ALuTreeOptionPickerComponent<T, O> implements AfterViewInit {\r\n\tloading$: Observable<boolean>;\r\n\r\n\tprotected _operators: ILuTreeOptionOperator<T>[] = [];\r\n\tprotected _operatorsQL: QueryList<ILuTreeOptionOperator<T>>;\r\n\t@ContentChildren(ALuTreeOptionOperator, { descendants: true }) set operatorsQL(ql: QueryList<ILuTreeOptionOperator<T>>) {\r\n\t\tthis._operatorsQL = ql;\r\n\r\n\t}\r\n\tprotected _onOpenSubscribers = [];\r\n\t@ContentChildren(ALuOnOpenSubscriber, { descendants: true }) set onOpenSubsQL(ql: QueryList<ILuOnOpenSubscriber>) {\r\n\t\tthis._onOpenSubscribers = ql.toArray();\r\n\t}\r\n\tprotected _onCloseSubscribers = [];\r\n\t@ContentChildren(ALuOnCloseSubscriber, { descendants: true }) set onCloseSubsQL(ql: QueryList<ILuOnCloseSubscriber>) {\r\n\t\tthis._onCloseSubscribers = ql.toArray();\r\n\t}\r\n\tprotected _onScrollBottomSubscribers = [];\r\n\t@ContentChildren(ALuOnScrollBottomSubscriber, { descendants: true }) set onScrollBottomSubsQL(ql: QueryList<ILuOnScrollBottomSubscriber>) {\r\n\t\tthis._onScrollBottomSubscribers = ql.toArray();\r\n\t}\r\n\r\n\tprotected _selectorsQL: QueryList<ILuTreeOptionSelector<T>>;\r\n\tprotected _selectors: ILuTreeOptionSelector<T>[] = [];\r\n\t@ContentChildren(ALuTreeOptionSelector, {descendants: true}) set selectorsQL(ql: QueryList<ILuTreeOptionSelector<T>>) {\r\n\t\tthis._selectorsQL = ql;\r\n\t}\r\n\r\n\tconstructor(\r\n\t\t_changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) document: Document,\r\n\t) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n\tonScrollBottom() {\r\n\t\tthis._onScrollBottomSubscribers.forEach(o => {\r\n\t\t\tif (!o.onScrollBottom) { return; }\r\n\t\t\to.onScrollBottom();\r\n\t\t});\r\n\t}\r\n\toverride onOpen() {\r\n\t\tthis._onOpenSubscribers.forEach(o => {\r\n\t\t\to.onOpen();\r\n\t\t});\r\n\t\tsuper.onOpen();\r\n\t}\r\n\toverride onClose() {\r\n\t\tthis._onCloseSubscribers.forEach(o => {\r\n\t\t\to.onClose();\r\n\t\t});\r\n\t\tsuper.onClose();\r\n\t}\r\n\toverride setValue(value: T | T[]) {\r\n\t\tsuper.setValue(value);\r\n\t\tthis._selectors.forEach(s => s.setValue(value));\r\n\t}\r\n\r\n\tprotected initOperators() {\r\n\t\tconst operators = this._operatorsQL.toArray();\r\n\t\tthis._operators = operators;\r\n\t\tlet options$: Observable<ILuTree<T>[]>;\r\n\t\toperators.forEach(operator => {\r\n\t\t\toperator.inOptions$ = options$;\r\n\t\t\toptions$ = operator.outOptions$;\r\n\t\t});\r\n\t\tconst lastOperator = operators[operators.length - 1];\r\n\t\tif (lastOperator && lastOperator.outOptions$) {\r\n\t\t\tthis.loading$ = lastOperator.outOptions$.pipe(\r\n\t\t\t\tfirst(),\r\n\t\t\t\tmapTo(false),\r\n\t\t\t\tstartWith(true),\r\n\t\t\t\tshareReplay(),\r\n\t\t\t);\r\n\t\t}\r\n\t}\r\n\tprotected initSelectors() {\r\n\t\tthis._selectors = this._selectorsQL.toArray();\r\n\t\tthis._subs.add(\r\n\t\t\tmerge(\r\n\t\t\t\tthis._selectors.map(s => s.onSelectValue),\r\n\t\t\t).pipe(\r\n\t\t\t\tmergeAll(),\r\n\t\t\t).subscribe(values => {\r\n\t\t\t\tthis._select(values);\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\toverride ngAfterViewInit() {\r\n\t\tsuper.ngAfterViewInit();\r\n\t\tthis.initOperators();\r\n\t\tthis.initSelectors();\r\n\t}\r\n}\r\n\r\n/**\r\n* advanced option picker panel\r\n*/\r\n@Component({\r\n\tselector: 'lu-tree-option-picker-advanced',\r\n\ttemplateUrl: './tree-option-picker-advanced.component.html',\r\n\tstyleUrls: ['./tree-option-picker.component.scss'],\r\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\r\n\tanimations: [luTransformPopover],\r\n\texportAs: 'LuOptionPicker',\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: ALuPickerPanel,\r\n\t\t\tuseExisting: forwardRef(() => LuTreeOptionPickerAdvancedComponent),\r\n\t\t},\r\n\t]\r\n})\r\nexport class LuTreeOptionPickerAdvancedComponent<T = any, O extends import('../item/tree-option-item.model').ILuTreeOptionItem<T> = import('../item/tree-option-item.model').ILuTreeOptionItem<T>> extends ALuTreeOptionPickerAdvancedComponent<T, O> {\r\n\tconstructor(\r\n\t\t_changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) document: Document,\r\n\t) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n}\r\n","<ng-template>\r\n\t<div class=\"lu-picker-panel lu-tree-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\" luScroll (onScrollBottom)=\"onScrollBottom()\">\r\n\t\t\t<ng-content [class.is-loading]=\"loading$ | async\"></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n"]}

package/esm2020/option/lib/picker/tree-option-picker.component.mjs

@@ -0,0 +1,171 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChildren, Directive, forwardRef, Inject, ViewContainerRef } from '@angular/core';
+import { ALuPickerPanel } from '@lucca-front/ng/picker';
+import { luTransformPopover } from '@lucca-front/ng/popover';
+import { merge } from 'rxjs';
+import { delay, map, startWith, switchMap } from 'rxjs/operators';
+import { ALuTreeOptionItem } from '../item/index';
+import { ALuOptionPickerComponent } from './option-picker.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/a11y";
+var ToggleMode;
+(function (ToggleMode) {
+    ToggleMode[ToggleMode["all"] = 0] = "all";
+    ToggleMode[ToggleMode["self"] = 1] = "self";
+    ToggleMode[ToggleMode["children"] = 2] = "children";
+})(ToggleMode || (ToggleMode = {}));
+export class ALuTreeOptionPickerComponent extends ALuOptionPickerComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+    }
+    set optionsQL(ql) {
+        this._optionsQL = ql;
+    }
+    set _options$(optionItems$) {
+        // reapply selected when the options change
+        this._subs.add(optionItems$
+            .subscribe(o => this._applySelected()));
+        // subscribe to any option.onSelect
+        const singleFlowSelect$ = optionItems$.pipe(switchMap(items => merge(...items.map(i => i.onSelect))));
+        const singleFlowSelectSelf$ = optionItems$.pipe(switchMap(items => merge(...items.map(i => i.onSelectSelf))));
+        const singleFlowSelectChildren$ = optionItems$.pipe(switchMap(items => merge(...items.map(i => i.onSelectChildren))));
+        this._subs.add(singleFlowSelect$
+            .subscribe(option => this._toggle(option, ToggleMode.all)));
+        this._subs.add(singleFlowSelectSelf$
+            .subscribe(option => this._toggle(option, ToggleMode.self)));
+        this._subs.add(singleFlowSelectChildren$
+            .subscribe(option => this._toggle(option, ToggleMode.children)));
+    }
+    _toggle(option, mod = ToggleMode.all) {
+        switch (mod) {
+            case ToggleMode.self:
+                return this._toggleSelf(option);
+            case ToggleMode.children:
+                return this._toggleChildren(option);
+            case ToggleMode.self:
+            default:
+                return this._toggleAll(option);
+        }
+    }
+    _toggleAll(option) {
+        const value = option.value;
+        if (!this.multiple) {
+            this._select(value);
+            return;
+        }
+        const allChildren = option.allChildren.map(i => i.value);
+        const values = this._value || [];
+        let newValues;
+        const selfSelected = values.some(v => this.optionComparer(v, value));
+        const allChildrenSelected = allChildren.every(child => values.some(v => this.optionComparer(v, child)));
+        if (selfSelected && allChildrenSelected) {
+            // remove option and its children
+            newValues = this._remove(values, [value, ...allChildren]);
+        }
+        else {
+            // add option and its children
+            newValues = this._add(values, [value, ...allChildren]);
+        }
+        this._select(newValues);
+    }
+    _toggleSelf(option) {
+        const value = option.value;
+        if (!this.multiple) {
+            this._select(value);
+            return;
+        }
+        const allChildren = option.allChildren.map(i => i.value);
+        const values = this._value || [];
+        const selfSelected = values.some(v => this.optionComparer(v, value));
+        const someChildSelected = allChildren.some(child => values.some(v => this.optionComparer(v, child)));
+        let newValues = this._remove(values, [...allChildren]);
+        if (selfSelected && !someChildSelected) {
+            // remove option
+            newValues = this._remove(newValues, [value]);
+        }
+        else {
+            // add option
+            newValues = this._add(newValues, [value]);
+        }
+        this._select(newValues);
+    }
+    _toggleChildren(option) {
+        const value = option.value;
+        if (!this.multiple) {
+            this._select(value);
+            return;
+        }
+        const allChildren = option.allChildren.map(i => i.value);
+        const values = this._value || [];
+        const selfSelected = values.some(v => this.optionComparer(v, value));
+        let newValues = this._remove(values, [value]);
+        const allChildrenSelected = allChildren.every(child => values.some(v => this.optionComparer(v, child)));
+        if (allChildrenSelected && !selfSelected) {
+            newValues = this._remove(newValues, allChildren);
+        }
+        else {
+            newValues = this._add(newValues, allChildren);
+        }
+        this._select(newValues);
+    }
+    _add(values, entries) {
+        const newEntries = entries.filter(entry => !values.some(v => this.optionComparer(v, entry)));
+        return [...values, ...newEntries];
+    }
+    _remove(values, entries) {
+        const entriesToKeep = values.filter(value => !entries.some(e => this.optionComparer(e, value)));
+        return [...entriesToKeep];
+    }
+    initItems() {
+        const items$ = this._optionsQL.changes
+            .pipe(startWith(this._optionsQL), map(q => q.toArray()), map(roots => roots.map(r => [r, ...r.allChildren]).reduce((agg, val) => [...agg, ...val], [])), delay(0));
+        this._subs.add(items$.subscribe(o => this._options = o || []));
+        this._options$ = items$;
+    }
+    ngAfterViewInit() {
+        this.initItems();
+    }
+}
+ALuTreeOptionPickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuTreeOptionPickerComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+ALuTreeOptionPickerComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: ALuTreeOptionPickerComponent, queries: [{ propertyName: "optionsQL", predicate: ALuTreeOptionItem, descendants: true }, { propertyName: "optionsQLVR", predicate: ALuTreeOptionItem, descendants: true, read: ViewContainerRef }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuTreeOptionPickerComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { optionsQL: [{
+                type: ContentChildren,
+                args: [ALuTreeOptionItem, { descendants: true }]
+            }], optionsQLVR: [{
+                type: ContentChildren,
+                args: [ALuTreeOptionItem, { descendants: true, read: ViewContainerRef }]
+            }] } });
+/**
+* basic tree option picker panel
+*/
+export class LuTreeOptionPickerComponent extends ALuTreeOptionPickerComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+    }
+}
+LuTreeOptionPickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+LuTreeOptionPickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: LuTreeOptionPickerComponent, selector: "lu-tree-option-picker", providers: [
+        {
+            provide: ALuPickerPanel,
+            useExisting: forwardRef(() => LuTreeOptionPickerComponent),
+        },
+    ], exportAs: ["LuTreeOptionPicker"], usesInheritance: true, ngImport: i0, template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-tree-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }], animations: [luTransformPopover], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lu-tree-option-picker', changeDetection: ChangeDetectionStrategy.OnPush, animations: [luTransformPopover], exportAs: 'LuTreeOptionPicker', providers: [
+                        {
+                            provide: ALuPickerPanel,
+                            useExisting: forwardRef(() => LuTreeOptionPickerComponent),
+                        },
+                    ], template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-tree-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-option-picker.component.js","sourceRoot":"","sources":["../../../../../../packages/ng/option/src/lib/picker/tree-option-picker.component.ts","../../../../../../packages/ng/option/src/lib/picker/tree-option-picker.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport {\r\n\tAfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, Directive, forwardRef, Inject, OnDestroy, QueryList, ViewContainerRef\r\n} from '@angular/core';\r\nimport { ALuPickerPanel } from '@lucca-front/ng/picker';\r\nimport { luTransformPopover } from '@lucca-front/ng/popover';\r\nimport { merge, Observable } from 'rxjs';\r\nimport { delay, map, startWith, switchMap } from 'rxjs/operators';\r\nimport { ALuTreeOptionItem } from '../item/index';\r\nimport { ALuOptionPickerComponent } from './option-picker.component';\r\nimport { ILuTreeOptionPickerPanel } from './tree-option-picker.model';\r\n\r\nenum ToggleMode {\r\n\tall,\r\n\tself,\r\n\tchildren,\r\n}\r\n\r\n@Directive()\r\nexport abstract class ALuTreeOptionPickerComponent<T, O extends import('../item/tree-option-item.model').ILuTreeOptionItem<T> = import('../item/tree-option-item.model').ILuTreeOptionItem<T>>\r\n\textends ALuOptionPickerComponent<T, O>\r\n\timplements ILuTreeOptionPickerPanel<T>, OnDestroy, AfterViewInit {\r\n\t@ContentChildren(ALuTreeOptionItem, { descendants: true }) override set optionsQL(ql: QueryList<O>) {\r\n\t\tthis._optionsQL = ql;\r\n\t}\r\n\t@ContentChildren(ALuTreeOptionItem, { descendants: true, read: ViewContainerRef }) optionsQLVR: QueryList<ViewContainerRef>;\r\n\tprotected override set _options$(optionItems$: Observable<O[]>) {\r\n\t\t// reapply selected when the options change\r\n\t\tthis._subs.add(\r\n\t\t\toptionItems$\r\n\t\t\t\t.subscribe(o => this._applySelected())\r\n\t\t);\r\n\t\t// subscribe to any option.onSelect\r\n\t\tconst singleFlowSelect$ = optionItems$.pipe(switchMap(\r\n\t\t\titems => merge(...items.map(i => i.onSelect))\r\n\t\t));\r\n\t\tconst singleFlowSelectSelf$ = optionItems$.pipe(switchMap(\r\n\t\t\titems => merge(...items.map(i => i.onSelectSelf))\r\n\t\t));\r\n\t\tconst singleFlowSelectChildren$ = optionItems$.pipe(switchMap(\r\n\t\t\titems => merge(...items.map(i => i.onSelectChildren))\r\n\t\t));\r\n\r\n\t\tthis._subs.add(\r\n\t\t\tsingleFlowSelect$\r\n\t\t\t\t.subscribe(option => this._toggle(option, ToggleMode.all))\r\n\t\t);\r\n\t\tthis._subs.add(\r\n\t\t\tsingleFlowSelectSelf$\r\n\t\t\t\t.subscribe(option => this._toggle(option, ToggleMode.self))\r\n\t\t);\r\n\t\tthis._subs.add(\r\n\t\t\tsingleFlowSelectChildren$\r\n\t\t\t\t.subscribe(option => this._toggle(option, ToggleMode.children))\r\n\t\t);\r\n\t}\r\n\tconstructor(\r\n\t\t_changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) document: Document,\r\n\t) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n\tprotected override _toggle(option: O, mod = ToggleMode.all) {\r\n\t\tswitch (mod) {\r\n\t\t\tcase ToggleMode.self:\r\n\t\t\t\treturn this._toggleSelf(option);\r\n\t\t\tcase ToggleMode.children:\r\n\t\t\t\treturn this._toggleChildren(option);\r\n\t\t\tcase ToggleMode.self:\r\n\t\t\tdefault:\r\n\t\t\t\treturn this._toggleAll(option);\r\n\t\t}\r\n\t}\r\n\tprotected _toggleAll(option: O) {\r\n\t\tconst value = option.value;\r\n\t\tif (!this.multiple) {\r\n\t\t\tthis._select(value);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst allChildren = option.allChildren.map(i => i.value);\r\n\t\tconst values = <T[]>this._value || [];\r\n\t\tlet newValues;\r\n\t\tconst selfSelected = values.some(v => this.optionComparer(v, value));\r\n\t\tconst allChildrenSelected = allChildren.every(child => values.some(v => this.optionComparer(v, child)));\r\n\t\tif (selfSelected && allChildrenSelected) {\r\n\t\t\t// remove option and its children\r\n\t\t\tnewValues = this._remove(values, [value, ...allChildren]);\r\n\t\t} else {\r\n\t\t\t// add option and its children\r\n\t\t\tnewValues = this._add(values, [value, ...allChildren]);\r\n\t\t}\r\n\t\tthis._select(newValues);\r\n\t}\r\n\tprotected _toggleSelf(option: O) {\r\n\t\tconst value = option.value;\r\n\t\tif (!this.multiple) {\r\n\t\t\tthis._select(value);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst allChildren = option.allChildren.map(i => i.value);\r\n\t\tconst values = <T[]>this._value || [];\r\n\t\tconst selfSelected = values.some(v => this.optionComparer(v, value));\r\n\t\tconst someChildSelected = allChildren.some(child => values.some(v => this.optionComparer(v, child)));\r\n\r\n\t\tlet newValues = this._remove(values, [...allChildren]);\r\n\t\tif (selfSelected && !someChildSelected) {\r\n\t\t\t// remove option\r\n\t\t\tnewValues = this._remove(newValues, [value]);\r\n\t\t} else {\r\n\t\t\t// add option\r\n\t\t\tnewValues = this._add(newValues, [value]);\r\n\t\t}\r\n\t\tthis._select(newValues);\r\n\t}\r\n\tprotected _toggleChildren(option: O) {\r\n\t\tconst value = option.value;\r\n\t\tif (!this.multiple) {\r\n\t\t\tthis._select(value);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst allChildren = option.allChildren.map(i => i.value);\r\n\t\tconst values = <T[]>this._value || [];\r\n\t\tconst selfSelected = values.some(v => this.optionComparer(v, value));\r\n\t\tlet newValues = this._remove(values, [value]);\r\n\t\tconst allChildrenSelected = allChildren.every(child => values.some(v => this.optionComparer(v, child)));\r\n\t\tif (allChildrenSelected && !selfSelected) {\r\n\t\t\tnewValues = this._remove(newValues, allChildren);\r\n\t\t} else {\r\n\t\t\tnewValues = this._add(newValues, allChildren);\r\n\t\t}\r\n\t\tthis._select(newValues);\r\n\t}\r\n\tprotected _add(values: T[], entries: T[]): T[] {\r\n\t\tconst newEntries = entries.filter(entry => !values.some(v => this.optionComparer(v, entry)));\r\n\t\treturn [...values, ...newEntries];\r\n\t}\r\n\tprotected _remove(values: T[], entries: T[]): T[] {\r\n\t\tconst entriesToKeep = values.filter(value => !entries.some(e => this.optionComparer(e, value)));\r\n\t\treturn [...entriesToKeep];\r\n\t}\r\n\r\n\tprotected override initItems() {\r\n\r\n\t\tconst items$ = this._optionsQL.changes\r\n\t\t\t.pipe(\r\n\t\t\t\tstartWith(this._optionsQL),\r\n\t\t\t\tmap<QueryList<O>, O[]>(q => q.toArray()),\r\n\t\t\t\tmap(roots => roots.map(r => [r, ...r.allChildren]).reduce((agg, val) => [...agg, ...val], [])),\r\n\t\t\t\tdelay(0),\r\n\t\t\t);\r\n\t\tthis._subs.add(items$.subscribe(o => this._options = o || []));\r\n\t\tthis._options$ = items$;\r\n\t}\r\n\toverride ngAfterViewInit() {\r\n\t\tthis.initItems();\r\n\t}\r\n}\r\n/**\r\n* basic tree option picker panel\r\n*/\r\n@Component({\r\n\tselector: 'lu-tree-option-picker',\r\n\ttemplateUrl: './tree-option-picker.component.html',\r\n\tstyleUrls: ['./tree-option-picker.component.scss'],\r\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\r\n\tanimations: [luTransformPopover],\r\n\texportAs: 'LuTreeOptionPicker',\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: ALuPickerPanel,\r\n\t\t\tuseExisting: forwardRef(() => LuTreeOptionPickerComponent),\r\n\t\t},\r\n\t]\r\n})\r\nexport class LuTreeOptionPickerComponent<T, O extends import('../item/tree-option-item.model').ILuTreeOptionItem<T> = import('../item/tree-option-item.model').ILuTreeOptionItem<T>>\r\n\textends ALuTreeOptionPickerComponent<T, O> {\r\n\tconstructor(\r\n\t\t_changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) document: Document,\r\n\t) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n}\r\n","<ng-template>\r\n\t<div class=\"lu-picker-panel lu-tree-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n"]}

package/esm2020/option/lib/picker/tree-option-picker.model.mjs

@@ -0,0 +1,4 @@
+import { ALuOptionPicker } from './option-picker.model';
+export class ALuTreeOptionPicker extends ALuOptionPicker {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1vcHRpb24tcGlja2VyLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmcvb3B0aW9uL3NyYy9saWIvcGlja2VyL3RyZWUtb3B0aW9uLXBpY2tlci5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZUFBZSxFQUF3QixNQUFNLHVCQUF1QixDQUFDO0FBSTlFLE1BQU0sT0FBZ0IsbUJBQW9GLFNBQVEsZUFBcUI7Q0FFdEkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJTHVUcmVlT3B0aW9uSXRlbSB9IGZyb20gJy4uL2l0ZW0vaW5kZXgnO1xyXG5pbXBvcnQgeyBBTHVPcHRpb25QaWNrZXIsIElMdU9wdGlvblBpY2tlclBhbmVsIH0gZnJvbSAnLi9vcHRpb24tcGlja2VyLm1vZGVsJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSUx1VHJlZU9wdGlvblBpY2tlclBhbmVsPFQgPSBhbnk+IGV4dGVuZHMgSUx1T3B0aW9uUGlja2VyUGFuZWw8VD4geyB9XHJcblxyXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQUx1VHJlZU9wdGlvblBpY2tlcjxUID0gYW55LCBJIGV4dGVuZHMgSUx1VHJlZU9wdGlvbkl0ZW08VD4gPSBJTHVUcmVlT3B0aW9uSXRlbTxUPj4gZXh0ZW5kcyBBTHVPcHRpb25QaWNrZXI8VCwgST4gaW1wbGVtZW50cyBJTHVUcmVlT3B0aW9uUGlja2VyUGFuZWw8VD4ge1xyXG5cclxufVxyXG4iXX0=

package/esm2020/option/lib/picker/tree-option-picker.module.mjs

@@ -0,0 +1,43 @@
+import { NgModule } from '@angular/core';
+import { LuTreeOptionPickerComponent } from './tree-option-picker.component';
+import { CommonModule } from '@angular/common';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { LuScrollModule } from '@lucca-front/ng/scroll';
+import { A11yModule } from '@angular/cdk/a11y';
+import { LuTreeOptionPickerAdvancedComponent } from './tree-option-picker-advanced.component';
+import * as i0 from "@angular/core";
+export class LuTreeOptionPickerModule {
+}
+LuTreeOptionPickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LuTreeOptionPickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerModule, declarations: [LuTreeOptionPickerComponent,
+        LuTreeOptionPickerAdvancedComponent], imports: [CommonModule,
+        OverlayModule,
+        LuScrollModule,
+        A11yModule], exports: [LuTreeOptionPickerComponent,
+        LuTreeOptionPickerAdvancedComponent] });
+LuTreeOptionPickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerModule, imports: [[
+            CommonModule,
+            OverlayModule,
+            LuScrollModule,
+            A11yModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuTreeOptionPickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        OverlayModule,
+                        LuScrollModule,
+                        A11yModule,
+                    ],
+                    declarations: [
+                        LuTreeOptionPickerComponent,
+                        LuTreeOptionPickerAdvancedComponent,
+                    ],
+                    exports: [
+                        LuTreeOptionPickerComponent,
+                        LuTreeOptionPickerAdvancedComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/option/lib/placeholder/option-placeholder.component.mjs

@@ -0,0 +1,24 @@
+import { Component, EventEmitter, Output, Inject } from '@angular/core';
+import { LuOptionPlaceholderIntl } from './option-placeholder.intl';
+import * as i0 from "@angular/core";
+export class LuOptionPlaceholderComponent {
+    constructor(intl) {
+        this.intl = intl;
+        this.onClear = new EventEmitter();
+    }
+    clear() {
+        this.onClear.emit();
+    }
+}
+LuOptionPlaceholderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPlaceholderComponent, deps: [{ token: LuOptionPlaceholderIntl }], target: i0.ɵɵFactoryTarget.Component });
+LuOptionPlaceholderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: LuOptionPlaceholderComponent, selector: "lu-option-placeholder", outputs: { onClear: "onClear" }, ngImport: i0, template: "<div class=\"optionPlaceholder\">\r\n\t<p class=\"optionPlaceholder-content u-marginBottomReset\">\r\n\t\t{{intl.placeholderDescription}}\r\n\t</p>\r\n\t<button class=\"link\" (click)=\"clear()\">\r\n\t\t{{intl.placeholderAction}}\r\n\t</button>\r\n</div>", styles: [".optionPlaceholder{display:block;padding:.5rem;padding:var(--components-options-item-padding-vertical) var(--components-options-item-padding-horizontal);font-style:italic;color:#96a6c5;color:var(--colors-text-light-color)}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lu-option-placeholder', template: "<div class=\"optionPlaceholder\">\r\n\t<p class=\"optionPlaceholder-content u-marginBottomReset\">\r\n\t\t{{intl.placeholderDescription}}\r\n\t</p>\r\n\t<button class=\"link\" (click)=\"clear()\">\r\n\t\t{{intl.placeholderAction}}\r\n\t</button>\r\n</div>", styles: [".optionPlaceholder{display:block;padding:.5rem;padding:var(--components-options-item-padding-vertical) var(--components-options-item-padding-horizontal);font-style:italic;color:#96a6c5;color:var(--colors-text-light-color)}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LuOptionPlaceholderIntl]
+                }] }]; }, propDecorators: { onClear: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLXBsYWNlaG9sZGVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL29wdGlvbi9zcmMvbGliL3BsYWNlaG9sZGVyL29wdGlvbi1wbGFjZWhvbGRlci5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9vcHRpb24vc3JjL2xpYi9wbGFjZWhvbGRlci9vcHRpb24tcGxhY2Vob2xkZXIuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN4RSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQzs7QUFRcEUsTUFBTSxPQUFPLDRCQUE0QjtJQUd4QyxZQUN5QyxJQUErQjtRQUEvQixTQUFJLEdBQUosSUFBSSxDQUEyQjtRQUg5RCxZQUFPLEdBQUcsSUFBSSxZQUFZLEVBQUUsQ0FBQztJQUlyQyxDQUFDO0lBRUgsS0FBSztRQUNKLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDckIsQ0FBQzs7eUhBVFcsNEJBQTRCLGtCQUkvQix1QkFBdUI7NkdBSnBCLDRCQUE0Qiw4RkNUekMsaVFBT007MkZERU8sNEJBQTRCO2tCQUx4QyxTQUFTOytCQUNDLHVCQUF1Qjs7MEJBUS9CLE1BQU07MkJBQUMsdUJBQXVCOzRDQUh0QixPQUFPO3NCQUFoQixNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBFdmVudEVtaXR0ZXIsIE91dHB1dCwgSW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEx1T3B0aW9uUGxhY2Vob2xkZXJJbnRsIH0gZnJvbSAnLi9vcHRpb24tcGxhY2Vob2xkZXIuaW50bCc7XHJcbmltcG9ydCB7IElMdU9wdGlvblBsYWNlaG9sZGVyTGFiZWwgfSBmcm9tICcuL29wdGlvbi1wbGFjZWhvbGRlci50cmFuc2xhdGUnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcblx0c2VsZWN0b3I6ICdsdS1vcHRpb24tcGxhY2Vob2xkZXInLFxyXG5cdHRlbXBsYXRlVXJsOiAnLi9vcHRpb24tcGxhY2Vob2xkZXIuY29tcG9uZW50Lmh0bWwnLFxyXG5cdHN0eWxlVXJsczogWycuL29wdGlvbi1wbGFjZWhvbGRlci5jb21wb25lbnQuc2NzcyddXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBMdU9wdGlvblBsYWNlaG9sZGVyQ29tcG9uZW50IHtcclxuXHRAT3V0cHV0KCkgb25DbGVhciA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcclxuXHJcblx0Y29uc3RydWN0b3IoXHJcblx0XHRASW5qZWN0KEx1T3B0aW9uUGxhY2Vob2xkZXJJbnRsKSBwdWJsaWMgaW50bDogSUx1T3B0aW9uUGxhY2Vob2xkZXJMYWJlbCxcclxuXHQpe31cclxuXHJcblx0Y2xlYXIoKSB7XHJcblx0XHR0aGlzLm9uQ2xlYXIuZW1pdCgpO1xyXG5cdH1cclxufVxyXG4iLCI8ZGl2IGNsYXNzPVwib3B0aW9uUGxhY2Vob2xkZXJcIj5cclxuXHQ8cCBjbGFzcz1cIm9wdGlvblBsYWNlaG9sZGVyLWNvbnRlbnQgdS1tYXJnaW5Cb3R0b21SZXNldFwiPlxyXG5cdFx0e3tpbnRsLnBsYWNlaG9sZGVyRGVzY3JpcHRpb259fVxyXG5cdDwvcD5cclxuXHQ8YnV0dG9uIGNsYXNzPVwibGlua1wiIChjbGljayk9XCJjbGVhcigpXCI+XHJcblx0XHR7e2ludGwucGxhY2Vob2xkZXJBY3Rpb259fVxyXG5cdDwvYnV0dG9uPlxyXG48L2Rpdj4iXX0=