@igo2/common 16.3.0 → 17.0.0-next.10

package/esm2022/dynamic-component/shared/dynamic-component.mjs

@@ -0,0 +1,183 @@
+import { Observable } from 'rxjs';
+/**
+ * This class is used in the DynamicComponentOutlet component. It holds
+ * a reference to a component factory and can render that component
+ * in a target element on demand. It's also possible to set inputs
+ * and to subscribe to outputs.
+ */
+export class DynamicComponent {
+    componentFactory;
+    /**
+     * Component reference
+     */
+    componentRef;
+    /**
+     * Subscriptions to the component's outputs. Those need
+     * to be unsubscribed when the component is destroyed.
+     */
+    subscriptions = [];
+    /**
+     * Component target element
+     */
+    target;
+    /**
+     * Component inputs
+     */
+    inputs = {};
+    /**
+     * Subscriptions to the component's async inputs
+     */
+    inputs$$ = {};
+    /**
+     * Subscribers to the component's outputs
+     */
+    subscribers = {};
+    constructor(componentFactory) {
+        this.componentFactory = componentFactory;
+    }
+    /**
+     * Render the component to a target element.
+     * Set it's inputs and subscribe to it's outputs.
+     * @param target Target element
+     */
+    setTarget(target) {
+        this.target = target;
+        this.componentRef = target.createComponent(this.componentFactory);
+        this.updateInputs(this.inputs);
+        this.updateSubscribers(this.subscribers);
+    }
+    /**
+     * Destroy this component. That means, removing from it's target
+     * element and unsubscribing to it's outputs.
+     */
+    destroy() {
+        if (this.target !== undefined) {
+            this.target.clear();
+        }
+        if (this.componentRef !== undefined) {
+            this.componentRef.destroy();
+            this.componentRef = undefined;
+        }
+        this.unobserveAllInputs();
+        this.unsubscribeAll();
+    }
+    /**
+     * Update the component inputs. This is an update so any
+     * key not defined won't be overwritten.
+     */
+    updateInputs(inputs) {
+        this.inputs = inputs;
+        if (this.componentRef === undefined) {
+            return;
+        }
+        const instance = this.componentRef.instance;
+        const allowedInputs = this.componentFactory.inputs;
+        allowedInputs.forEach((value) => {
+            const key = value.propName;
+            this.unobserveInput(key);
+            const inputValue = inputs[key];
+            if (inputs.hasOwnProperty(key)) {
+                if (inputValue instanceof Observable) {
+                    this.observeInput(key, inputValue);
+                }
+                else {
+                    this.setInputValue(instance, key, inputValue);
+                }
+            }
+        });
+        if (typeof instance.onUpdateInputs === 'function') {
+            instance.onUpdateInputs();
+        }
+    }
+    /**
+     * Set an instance's input value
+     * @param instance Component instance
+     * @param key Input key
+     * @param value Input value
+     */
+    setInputValue(instance, key, value) {
+        const currentValue = instance[key];
+        if (value === currentValue) {
+            return;
+        }
+        const prototype = Object.getPrototypeOf(instance);
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+        if (descriptor !== undefined && descriptor.set !== undefined) {
+            descriptor.set.call(instance, value);
+        }
+        else {
+            instance[key] = value;
+        }
+    }
+    /**
+     * Update the component subscribers. This is an update so any
+     * key not defined won't be overwritten.
+     */
+    updateSubscribers(subscribers) {
+        this.subscribers = subscribers;
+        if (this.componentRef === undefined) {
+            return;
+        }
+        const instance = this.componentRef.instance;
+        const allowedSubscribers = this.componentFactory.outputs;
+        allowedSubscribers.forEach((value) => {
+            const key = value.propName;
+            if (subscribers.hasOwnProperty(key)) {
+                const emitter = instance[key];
+                const subscriber = subscribers[key];
+                if (Array.isArray(subscriber)) {
+                    subscriber.forEach((_subscriber) => {
+                        this.subscriptions.push(emitter.subscribe(_subscriber));
+                    });
+                }
+                else {
+                    this.subscriptions.push(emitter.subscribe(subscriber));
+                }
+            }
+        });
+    }
+    /**
+     * Subscribe to an observable input and update the component's input value
+     * accordingly
+     * @param key Input key
+     * @param observable Observable
+     */
+    observeInput(key, observable) {
+        this.inputs$$[key] = observable.subscribe((value) => {
+            const instance = this.componentRef.instance;
+            this.setInputValue(instance, key, value);
+            if (typeof instance.onUpdateInputs === 'function') {
+                instance.onUpdateInputs();
+            }
+        });
+    }
+    /**
+     * Unsubscribe to an observable input
+     * @param key Input key
+     */
+    unobserveInput(key) {
+        if (this.inputs$$[key] !== undefined) {
+            this.inputs$$[key].unsubscribe();
+            this.inputs$$[key] = undefined;
+        }
+    }
+    /**
+     * Unsubscribe to all outputs.
+     */
+    unobserveAllInputs() {
+        Object.values(this.inputs$$).forEach((s) => {
+            if (s !== undefined) {
+                s.unsubscribe();
+            }
+        });
+        this.inputs$$ = {};
+    }
+    /**
+     * Unsubscribe to all outputs.
+     */
+    unsubscribeAll() {
+        this.subscriptions.forEach((s) => s.unsubscribe());
+        this.subscriptions = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-component.js","sourceRoot":"","sources":["../../../../../packages/common/dynamic-component/src/shared/dynamic-component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentFactory,\n  ComponentRef,\n  ViewContainerRef\n} from '@angular/core';\n\nimport { Observable, Subscription } from 'rxjs';\n\n/**\n * This class is used in the DynamicComponentOutlet component. It holds\n * a reference to a component factory and can render that component\n * in a target element on demand. It's also possible to set inputs\n * and to subscribe to outputs.\n */\nexport class DynamicComponent<C> {\n  /**\n   * Component reference\n   */\n  private componentRef: ComponentRef<C>;\n\n  /**\n   * Subscriptions to the component's outputs. Those need\n   * to be unsubscribed when the component is destroyed.\n   */\n  private subscriptions: Subscription[] = [];\n\n  /**\n   * Component target element\n   */\n  private target: ViewContainerRef;\n\n  /**\n   * Component inputs\n   */\n  private inputs: { [key: string]: any } = {};\n\n  /**\n   * Subscriptions to the component's async inputs\n   */\n  private inputs$$: { [key: string]: Subscription } = {};\n\n  /**\n   * Subscribers to the component's outputs\n   */\n  private subscribers: { [key: string]: (event: any) => void } = {};\n\n  constructor(private componentFactory: ComponentFactory<C>) {}\n\n  /**\n   * Render the component to a target element.\n   * Set it's inputs and subscribe to it's outputs.\n   * @param target Target element\n   */\n  setTarget(target: ViewContainerRef) {\n    this.target = target;\n    this.componentRef = target.createComponent(this.componentFactory);\n    this.updateInputs(this.inputs);\n    this.updateSubscribers(this.subscribers);\n  }\n\n  /**\n   * Destroy this component. That means, removing from it's target\n   * element and unsubscribing to it's outputs.\n   */\n  destroy() {\n    if (this.target !== undefined) {\n      this.target.clear();\n    }\n    if (this.componentRef !== undefined) {\n      this.componentRef.destroy();\n      this.componentRef = undefined;\n    }\n    this.unobserveAllInputs();\n    this.unsubscribeAll();\n  }\n\n  /**\n   * Update the component inputs. This is an update so any\n   * key not defined won't be overwritten.\n   */\n  updateInputs(inputs: { [key: string]: any }) {\n    this.inputs = inputs;\n    if (this.componentRef === undefined) {\n      return;\n    }\n\n    const instance = this.componentRef.instance;\n    const allowedInputs = this.componentFactory.inputs;\n    allowedInputs.forEach(\n      (value: { propName: string; templateName: string }) => {\n        const key = value.propName;\n\n        this.unobserveInput(key);\n\n        const inputValue = inputs[key];\n        if (inputs.hasOwnProperty(key)) {\n          if (inputValue instanceof Observable) {\n            this.observeInput(key, inputValue);\n          } else {\n            this.setInputValue(instance, key, inputValue);\n          }\n        }\n      }\n    );\n\n    if (typeof (instance as any).onUpdateInputs === 'function') {\n      (instance as any).onUpdateInputs();\n    }\n  }\n\n  /**\n   * Set an instance's input value\n   * @param instance Component instance\n   * @param key Input key\n   * @param value Input value\n   */\n  private setInputValue(instance: C, key: string, value: any) {\n    const currentValue = instance[key];\n    if (value === currentValue) {\n      return;\n    }\n\n    const prototype = Object.getPrototypeOf(instance);\n    const descriptor = Object.getOwnPropertyDescriptor(prototype, key);\n    if (descriptor !== undefined && descriptor.set !== undefined) {\n      descriptor.set.call(instance, value);\n    } else {\n      instance[key] = value;\n    }\n  }\n\n  /**\n   * Update the component subscribers. This is an update so any\n   * key not defined won't be overwritten.\n   */\n  updateSubscribers(subscribers: { [key: string]: (event: any) => void }) {\n    this.subscribers = subscribers;\n    if (this.componentRef === undefined) {\n      return;\n    }\n\n    const instance = this.componentRef.instance;\n    const allowedSubscribers = this.componentFactory.outputs;\n    allowedSubscribers.forEach(\n      (value: { propName: string; templateName: string }) => {\n        const key = value.propName;\n        if (subscribers.hasOwnProperty(key)) {\n          const emitter = instance[key];\n          const subscriber = subscribers[key];\n          if (Array.isArray(subscriber)) {\n            subscriber.forEach((_subscriber) => {\n              this.subscriptions.push(emitter.subscribe(_subscriber));\n            });\n          } else {\n            this.subscriptions.push(emitter.subscribe(subscriber));\n          }\n        }\n      }\n    );\n  }\n\n  /**\n   * Subscribe to an observable input and update the component's input value\n   * accordingly\n   * @param key Input key\n   * @param observable Observable\n   */\n  private observeInput(key: string, observable: Observable<any>) {\n    this.inputs$$[key] = observable.subscribe((value: any) => {\n      const instance = this.componentRef.instance;\n      this.setInputValue(instance, key, value);\n\n      if (typeof (instance as any).onUpdateInputs === 'function') {\n        (instance as any).onUpdateInputs();\n      }\n    });\n  }\n\n  /**\n   * Unsubscribe to an observable input\n   * @param key Input key\n   */\n  private unobserveInput(key: string) {\n    if (this.inputs$$[key] !== undefined) {\n      this.inputs$$[key].unsubscribe();\n      this.inputs$$[key] = undefined;\n    }\n  }\n\n  /**\n   * Unsubscribe to all outputs.\n   */\n  private unobserveAllInputs() {\n    Object.values(this.inputs$$).forEach((s: Subscription | undefined) => {\n      if (s !== undefined) {\n        s.unsubscribe();\n      }\n    });\n    this.inputs$$ = {};\n  }\n\n  /**\n   * Unsubscribe to all outputs.\n   */\n  private unsubscribeAll() {\n    this.subscriptions.forEach((s: Subscription) => s.unsubscribe());\n    this.subscriptions = [];\n  }\n}\n"]}

package/esm2022/dynamic-component/shared/dynamic-component.service.mjs

@@ -0,0 +1,30 @@
+import { ComponentFactoryResolver, Injectable } from '@angular/core';
+import { DynamicComponent } from './dynamic-component';
+import * as i0 from "@angular/core";
+/**
+ * Service to creates DynamicComponent instances from base component classes
+ */
+export class DynamicComponentService {
+    resolver;
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    /**
+     * Creates a DynamicComponent instance from a base component class
+     * @param componentCls The component class
+     * @returns DynamicComponent instance
+     */
+    create(componentCls) {
+        const factory = this.resolver.resolveComponentFactory(componentCls);
+        return new DynamicComponent(factory);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: DynamicComponentService, deps: [{ token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: DynamicComponentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: DynamicComponentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.ComponentFactoryResolver }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1jb21wb25lbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9keW5hbWljLWNvbXBvbmVudC9zcmMvc2hhcmVkL2R5bmFtaWMtY29tcG9uZW50LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHdCQUF3QixFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVyRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7QUFFdkQ7O0dBRUc7QUFJSCxNQUFNLE9BQU8sdUJBQXVCO0lBQ2Q7SUFBcEIsWUFBb0IsUUFBa0M7UUFBbEMsYUFBUSxHQUFSLFFBQVEsQ0FBMEI7SUFBRyxDQUFDO0lBRTFEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsWUFBaUI7UUFDdEIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyx1QkFBdUIsQ0FBQyxZQUFtQixDQUFDLENBQUM7UUFDM0UsT0FBTyxJQUFJLGdCQUFnQixDQUFzQixPQUFPLENBQUMsQ0FBQztJQUM1RCxDQUFDO3VHQVhVLHVCQUF1QjsyR0FBdkIsdUJBQXVCLGNBRnRCLE1BQU07OzJGQUVQLHVCQUF1QjtrQkFIbkMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnRGYWN0b3J5UmVzb2x2ZXIsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgRHluYW1pY0NvbXBvbmVudCB9IGZyb20gJy4vZHluYW1pYy1jb21wb25lbnQnO1xuXG4vKipcbiAqIFNlcnZpY2UgdG8gY3JlYXRlcyBEeW5hbWljQ29tcG9uZW50IGluc3RhbmNlcyBmcm9tIGJhc2UgY29tcG9uZW50IGNsYXNzZXNcbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgRHluYW1pY0NvbXBvbmVudFNlcnZpY2Uge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlc29sdmVyOiBDb21wb25lbnRGYWN0b3J5UmVzb2x2ZXIpIHt9XG5cbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBEeW5hbWljQ29tcG9uZW50IGluc3RhbmNlIGZyb20gYSBiYXNlIGNvbXBvbmVudCBjbGFzc1xuICAgKiBAcGFyYW0gY29tcG9uZW50Q2xzIFRoZSBjb21wb25lbnQgY2xhc3NcbiAgICogQHJldHVybnMgRHluYW1pY0NvbXBvbmVudCBpbnN0YW5jZVxuICAgKi9cbiAgY3JlYXRlKGNvbXBvbmVudENsczogYW55KTogRHluYW1pY0NvbXBvbmVudDxhbnk+IHtcbiAgICBjb25zdCBmYWN0b3J5ID0gdGhpcy5yZXNvbHZlci5yZXNvbHZlQ29tcG9uZW50RmFjdG9yeShjb21wb25lbnRDbHMgYXMgYW55KTtcbiAgICByZXR1cm4gbmV3IER5bmFtaWNDb21wb25lbnQ8dHlwZW9mIGNvbXBvbmVudENscz4oZmFjdG9yeSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/dynamic-component/shared/index.mjs

@@ -0,0 +1,4 @@
+export * from './dynamic-component.interfaces';
+export * from './dynamic-component';
+export * from './dynamic-component.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vZHluYW1pYy1jb21wb25lbnQvc3JjL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1jb21wb25lbnQuaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1jb21wb25lbnQuc2VydmljZSc7XG4iXX0=

package/esm2022/entity/entity-selector/entity-selector.component.mjs

@@ -0,0 +1,174 @@
+import { AsyncPipe, NgFor, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Output } from '@angular/core';
+import { MatOptionModule } from '@angular/material/core';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatSelectModule } from '@angular/material/select';
+import { BehaviorSubject } from 'rxjs';
+import { getEntityTitle } from '../shared/entity.utils';
+import { EntityStore } from '../shared/store';
+import { EntityStoreWatcher } from '../shared/watcher';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/form-field";
+import * as i2 from "@angular/material/select";
+import * as i3 from "@angular/material/core";
+export class EntitySelectorComponent {
+    cdRef;
+    /**
+     * The selected entity
+     * @internal
+     */
+    selected$ = new BehaviorSubject(undefined);
+    /**
+     * The current multi select option text
+     * @internal
+     */
+    multiText$ = new BehaviorSubject(undefined);
+    multiSelectValue = { id: 'IGO_MULTI_SELECT' };
+    emptyValue = { id: 'IGO_EMPTY_SELECT' };
+    /**
+     * Subscription to the selected entity
+     */
+    selected$$;
+    /**
+     * Store watcher
+     */
+    watcher;
+    /**
+     * Entity store
+     */
+    store;
+    /**
+     * Title accessor
+     */
+    titleAccessor = getEntityTitle;
+    /**
+     * Text to display when nothing is selected
+     */
+    emptyText = undefined;
+    /**
+     * Wheter selecting many entities is allowed
+     */
+    multi = false;
+    /**
+     * Text to display for the select all option
+     */
+    multiAllText = 'All';
+    /**
+     * Text to display for the select none option
+     */
+    multiNoneText = 'None';
+    /**
+     * Field placeholder
+     */
+    placeholder;
+    /**
+     * Wheter the selector is disabled or not
+     */
+    disabled = false;
+    /**
+     * Event emitted when the selection changes
+     */
+    selectedChange = new EventEmitter();
+    constructor(cdRef) {
+        this.cdRef = cdRef;
+    }
+    /**
+     * Create a store watcher and subscribe to the selected entity
+     * @internal
+     */
+    ngOnInit() {
+        this.watcher = new EntityStoreWatcher(this.store, this.cdRef);
+        this.selected$$ = this.store.stateView
+            .manyBy$((record) => record.state.selected === true)
+            .subscribe((records) => {
+            const entities = records.map((record) => record.entity);
+            this.onSelectFromStore(entities);
+        });
+    }
+    /**
+     * Unsubscribe to the selected entity and destroy the store watcher
+     * @internal
+     */
+    ngOnDestroy() {
+        this.watcher.destroy();
+        this.selected$$.unsubscribe();
+    }
+    /**
+     * On selection change, update the store's state and emit an event
+     * @internal
+     */
+    onSelectionChange(event) {
+        const values = event.value instanceof Array ? event.value : [event.value];
+        const multiSelect = values.find((_value) => _value === this.multiSelectValue);
+        let entities = values.filter((_value) => _value !== this.multiSelectValue);
+        if (multiSelect !== undefined) {
+            if (entities.length === this.store.count) {
+                entities = [];
+            }
+            else if (entities.length < this.store.count) {
+                entities = this.store.all();
+            }
+        }
+        entities = entities.filter((entity) => entity !== this.emptyValue);
+        if (entities.length === 0) {
+            this.store.state.updateAll({ selected: false });
+        }
+        else {
+            this.store.state.updateMany(entities, { selected: true }, true);
+        }
+        const value = this.multi ? entities : event.value;
+        this.selectedChange.emit({ selected: true, value });
+    }
+    onSelectFromStore(entities) {
+        if (this.multi === true) {
+            this.selected$.next(entities);
+        }
+        else {
+            const entity = entities.length > 0 ? entities[0] : undefined;
+            this.selected$.next(entity);
+        }
+        this.updateMultiToggleWithEntities(entities);
+    }
+    updateMultiToggleWithEntities(entities) {
+        if (entities.length === this.store.count &&
+            this.multiText$.value !== this.multiNoneText) {
+            this.multiText$.next(this.multiNoneText);
+        }
+        else if (entities.length < this.store.count &&
+            this.multiText$.value !== this.multiAllText) {
+            this.multiText$.next(this.multiAllText);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EntitySelectorComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: EntitySelectorComponent, isStandalone: true, selector: "igo-entity-selector", inputs: { store: "store", titleAccessor: "titleAccessor", emptyText: "emptyText", multi: "multi", multiAllText: "multiAllText", multiNoneText: "multiNoneText", placeholder: "placeholder", disabled: "disabled" }, outputs: { selectedChange: "selectedChange" }, ngImport: i0, template: "<mat-form-field class=\"igo-entity-selector\" subscriptSizing=\"dynamic\">\n  <mat-select\n    [disabled]=\"disabled\"\n    [value]=\"selected$ | async\"\n    [multiple]=\"multi\"\n    [placeholder]=\"placeholder\"\n    (selectionChange)=\"onSelectionChange($event)\"\n  >\n    <mat-option\n      *ngIf=\"emptyText !== undefined && multi === false\"\n      [value]=\"emptyValue\"\n      >{{ emptyText }}</mat-option\n    >\n    <mat-option *ngIf=\"multi === true\" [value]=\"multiSelectValue\">{{\n      multiText$ | async\n    }}</mat-option>\n    <ng-template ngFor let-record [ngForOf]=\"store.stateView.all$() | async\">\n      <mat-option [value]=\"record.entity\">\n        {{ titleAccessor(record.entity) }}\n      </mat-option>\n    </ng-template>\n  </mat-select>\n</mat-form-field>\n", styles: ["mat-form-field{width:100%}\n"], dependencies: [{ kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i1.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i2.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i3.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatOptionModule }, { kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EntitySelectorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-entity-selector', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        MatFormFieldModule,
+                        MatSelectModule,
+                        NgIf,
+                        MatOptionModule,
+                        NgFor,
+                        AsyncPipe
+                    ], template: "<mat-form-field class=\"igo-entity-selector\" subscriptSizing=\"dynamic\">\n  <mat-select\n    [disabled]=\"disabled\"\n    [value]=\"selected$ | async\"\n    [multiple]=\"multi\"\n    [placeholder]=\"placeholder\"\n    (selectionChange)=\"onSelectionChange($event)\"\n  >\n    <mat-option\n      *ngIf=\"emptyText !== undefined && multi === false\"\n      [value]=\"emptyValue\"\n      >{{ emptyText }}</mat-option\n    >\n    <mat-option *ngIf=\"multi === true\" [value]=\"multiSelectValue\">{{\n      multiText$ | async\n    }}</mat-option>\n    <ng-template ngFor let-record [ngForOf]=\"store.stateView.all$() | async\">\n      <mat-option [value]=\"record.entity\">\n        {{ titleAccessor(record.entity) }}\n      </mat-option>\n    </ng-template>\n  </mat-select>\n</mat-form-field>\n", styles: ["mat-form-field{width:100%}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { store: [{
+                type: Input
+            }], titleAccessor: [{
+                type: Input
+            }], emptyText: [{
+                type: Input
+            }], multi: [{
+                type: Input
+            }], multiAllText: [{
+                type: Input
+            }], multiNoneText: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], selectedChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-selector.component.js","sourceRoot":"","sources":["../../../../../packages/common/entity/src/entity-selector/entity-selector.component.ts","../../../../../packages/common/entity/src/entity-selector/entity-selector.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output\n} from '@angular/core';\nimport { MatOptionModule } from '@angular/material/core';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatSelectModule } from '@angular/material/select';\n\nimport { BehaviorSubject, Subscription } from 'rxjs';\n\nimport { EntityRecord } from '../shared/entity.interfaces';\nimport { getEntityTitle } from '../shared/entity.utils';\nimport { EntityStore } from '../shared/store';\nimport { EntityStoreWatcher } from '../shared/watcher';\n\nexport interface EntitySelectorChange<T = any> {\n  selected: boolean;\n  value: T;\n}\n@Component({\n  selector: 'igo-entity-selector',\n  templateUrl: './entity-selector.component.html',\n  styleUrls: ['./entity-selector.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    MatFormFieldModule,\n    MatSelectModule,\n    NgIf,\n    MatOptionModule,\n    NgFor,\n    AsyncPipe\n  ]\n})\nexport class EntitySelectorComponent implements OnInit, OnDestroy {\n  /**\n   * The selected entity\n   * @internal\n   */\n  readonly selected$ = new BehaviorSubject<object>(undefined);\n\n  /**\n   * The current multi select option text\n   * @internal\n   */\n  readonly multiText$ = new BehaviorSubject<string>(undefined);\n\n  readonly multiSelectValue = { id: 'IGO_MULTI_SELECT' };\n\n  readonly emptyValue = { id: 'IGO_EMPTY_SELECT' };\n\n  /**\n   * Subscription to the selected entity\n   */\n  private selected$$: Subscription;\n\n  /**\n   * Store watcher\n   */\n  private watcher: EntityStoreWatcher<object>;\n\n  /**\n   * Entity store\n   */\n  @Input() store: EntityStore<object>;\n\n  /**\n   * Title accessor\n   */\n  @Input() titleAccessor: (object) => string = getEntityTitle;\n\n  /**\n   * Text to display when nothing is selected\n   */\n  @Input() emptyText: string = undefined;\n\n  /**\n   * Wheter selecting many entities is allowed\n   */\n  @Input() multi: boolean = false;\n\n  /**\n   * Text to display for the select all option\n   */\n  @Input() multiAllText: string = 'All';\n\n  /**\n   * Text to display for the select none option\n   */\n  @Input() multiNoneText: string = 'None';\n\n  /**\n   * Field placeholder\n   */\n  @Input() placeholder: string;\n\n  /**\n   * Wheter the selector is disabled or not\n   */\n  @Input() disabled: boolean = false;\n\n  /**\n   * Event emitted when the selection changes\n   */\n  @Output() selectedChange = new EventEmitter<EntitySelectorChange>();\n\n  constructor(private cdRef: ChangeDetectorRef) {}\n\n  /**\n   * Create a store watcher and subscribe to the selected entity\n   * @internal\n   */\n  ngOnInit() {\n    this.watcher = new EntityStoreWatcher(this.store, this.cdRef);\n\n    this.selected$$ = this.store.stateView\n      .manyBy$((record: EntityRecord<object>) => record.state.selected === true)\n      .subscribe((records: EntityRecord<object>[]) => {\n        const entities = records.map(\n          (record: EntityRecord<object>) => record.entity\n        );\n        this.onSelectFromStore(entities);\n      });\n  }\n\n  /**\n   * Unsubscribe to the selected entity and destroy the store watcher\n   * @internal\n   */\n  ngOnDestroy() {\n    this.watcher.destroy();\n    this.selected$$.unsubscribe();\n  }\n\n  /**\n   * On selection change, update the store's state and emit an event\n   * @internal\n   */\n  onSelectionChange(event: { value: object | undefined }) {\n    const values = event.value instanceof Array ? event.value : [event.value];\n\n    const multiSelect = values.find(\n      (_value: object) => _value === this.multiSelectValue\n    );\n    let entities = values.filter(\n      (_value: object) => _value !== this.multiSelectValue\n    );\n    if (multiSelect !== undefined) {\n      if (entities.length === this.store.count) {\n        entities = [];\n      } else if (entities.length < this.store.count) {\n        entities = this.store.all();\n      }\n    }\n\n    entities = entities.filter((entity: object) => entity !== this.emptyValue);\n    if (entities.length === 0) {\n      this.store.state.updateAll({ selected: false });\n    } else {\n      this.store.state.updateMany(entities, { selected: true }, true);\n    }\n\n    const value = this.multi ? entities : event.value;\n    this.selectedChange.emit({ selected: true, value });\n  }\n\n  private onSelectFromStore(entities: object[]) {\n    if (this.multi === true) {\n      this.selected$.next(entities);\n    } else {\n      const entity = entities.length > 0 ? entities[0] : undefined;\n      this.selected$.next(entity);\n    }\n\n    this.updateMultiToggleWithEntities(entities);\n  }\n\n  private updateMultiToggleWithEntities(entities: object[]) {\n    if (\n      entities.length === this.store.count &&\n      this.multiText$.value !== this.multiNoneText\n    ) {\n      this.multiText$.next(this.multiNoneText);\n    } else if (\n      entities.length < this.store.count &&\n      this.multiText$.value !== this.multiAllText\n    ) {\n      this.multiText$.next(this.multiAllText);\n    }\n  }\n}\n","<mat-form-field class=\"igo-entity-selector\" subscriptSizing=\"dynamic\">\n  <mat-select\n    [disabled]=\"disabled\"\n    [value]=\"selected$ | async\"\n    [multiple]=\"multi\"\n    [placeholder]=\"placeholder\"\n    (selectionChange)=\"onSelectionChange($event)\"\n  >\n    <mat-option\n      *ngIf=\"emptyText !== undefined && multi === false\"\n      [value]=\"emptyValue\"\n      >{{ emptyText }}</mat-option\n    >\n    <mat-option *ngIf=\"multi === true\" [value]=\"multiSelectValue\">{{\n      multiText$ | async\n    }}</mat-option>\n    <ng-template ngFor let-record [ngForOf]=\"store.stateView.all$() | async\">\n      <mat-option [value]=\"record.entity\">\n        {{ titleAccessor(record.entity) }}\n      </mat-option>\n    </ng-template>\n  </mat-select>\n</mat-form-field>\n"]}

package/esm2022/entity/entity-selector/entity-selector.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { EntitySelectorComponent } from './entity-selector.component';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated import the EntitySelectorComponent directly
+ */
+export class IgoEntitySelectorModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IgoEntitySelectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.9", ngImport: i0, type: IgoEntitySelectorModule, imports: [EntitySelectorComponent], exports: [EntitySelectorComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IgoEntitySelectorModule, imports: [EntitySelectorComponent] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: IgoEntitySelectorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [EntitySelectorComponent],
+                    exports: [EntitySelectorComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LXNlbGVjdG9yLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9lbnRpdHkvc3JjL2VudGl0eS1zZWxlY3Rvci9lbnRpdHktc2VsZWN0b3IubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7O0FBRXRFOztHQUVHO0FBS0gsTUFBTSxPQUFPLHVCQUF1Qjt1R0FBdkIsdUJBQXVCO3dHQUF2Qix1QkFBdUIsWUFIeEIsdUJBQXVCLGFBQ3ZCLHVCQUF1Qjt3R0FFdEIsdUJBQXVCLFlBSHhCLHVCQUF1Qjs7MkZBR3RCLHVCQUF1QjtrQkFKbkMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyx1QkFBdUIsQ0FBQztvQkFDbEMsT0FBTyxFQUFFLENBQUMsdUJBQXVCLENBQUM7aUJBQ25DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgRW50aXR5U2VsZWN0b3JDb21wb25lbnQgfSBmcm9tICcuL2VudGl0eS1zZWxlY3Rvci5jb21wb25lbnQnO1xuXG4vKipcbiAqIEBkZXByZWNhdGVkIGltcG9ydCB0aGUgRW50aXR5U2VsZWN0b3JDb21wb25lbnQgZGlyZWN0bHlcbiAqL1xuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0VudGl0eVNlbGVjdG9yQ29tcG9uZW50XSxcbiAgZXhwb3J0czogW0VudGl0eVNlbGVjdG9yQ29tcG9uZW50XVxufSlcbmV4cG9ydCBjbGFzcyBJZ29FbnRpdHlTZWxlY3Rvck1vZHVsZSB7fVxuIl19

package/esm2022/entity/entity-selector/index.mjs

@@ -0,0 +1,3 @@
+export * from './entity-selector.module';
+export * from './entity-selector.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vZW50aXR5L3NyYy9lbnRpdHktc2VsZWN0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lbnRpdHktc2VsZWN0b3IubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZW50aXR5LXNlbGVjdG9yLmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/entity/entity-table/entity-table-row.directive.mjs

@@ -0,0 +1,138 @@
+import { Directive, ElementRef, EventEmitter, HostListener, Input, Output, Renderer2 } from '@angular/core';
+import scrollIntoView from 'scroll-into-view-if-needed';
+import { EntityTableScrollBehavior } from '../shared/entity.enums';
+import * as i0 from "@angular/core";
+/**
+ * Directive that handles an entity table row click and selection.
+ */
+export class EntityTableRowDirective {
+    renderer;
+    el;
+    /**
+     * Class added to a selected row
+     */
+    static selectedCls = 'igo-entity-table-row-selected';
+    /**
+     * Class added to a highlighted row
+     */
+    static highlightedCls = 'igo-entity-table-row-highlighted';
+    /**
+     * Whether a row supports selection
+     */
+    selection = false;
+    /**
+     * Whether clicking a row should select it (if selection is true)
+     */
+    selectOnClick = true;
+    /**
+     * Whether the selected row should be highlighted
+     */
+    highlightSelection = true;
+    /**
+     * Whether a row is selected
+     */
+    set selected(value) {
+        if (this.selection === false) {
+            return;
+        }
+        if (value === this._selected) {
+            return;
+        }
+        this.toggleSelected(value);
+        this.scroll();
+    }
+    get selected() {
+        return this._selected;
+    }
+    _selected = false;
+    /**
+     * Scroll behavior on selection
+     */
+    scrollBehavior = EntityTableScrollBehavior.Auto;
+    /**
+     * Event emitted when a row is selected
+     */
+    select = new EventEmitter();
+    /**
+     * When a row is clicked, select it if it's supported
+     * @ignore
+     */
+    onClick() {
+        if (this.selection === false || this.selectOnClick === false) {
+            return;
+        }
+        this.toggleSelected(true);
+        this.select.emit(this);
+    }
+    constructor(renderer, el) {
+        this.renderer = renderer;
+        this.el = el;
+    }
+    /**
+     * Select a row and add or remove the selected class from it
+     * @param selected Whether the row should be selected
+     */
+    toggleSelected(selected) {
+        this._selected = selected;
+        if (selected === true) {
+            this.addCls(EntityTableRowDirective.selectedCls);
+            if (this.highlightSelection === true) {
+                this.addCls(EntityTableRowDirective.highlightedCls);
+            }
+        }
+        else {
+            this.removeCls(EntityTableRowDirective.selectedCls);
+            this.removeCls(EntityTableRowDirective.highlightedCls);
+        }
+    }
+    /**
+     * Scroll to the selected row
+     */
+    scroll() {
+        if (this._selected === true) {
+            scrollIntoView(this.el.nativeElement, {
+                scrollMode: 'if-needed',
+                behavior: 'smooth',
+                block: 'end',
+                inline: 'nearest'
+            });
+        }
+    }
+    /**
+     * Add the selected CSS class
+     */
+    addCls(cls) {
+        this.renderer.addClass(this.el.nativeElement, cls);
+    }
+    /**
+     * Remove the selected CSS class
+     */
+    removeCls(cls) {
+        this.renderer.removeClass(this.el.nativeElement, cls);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EntityTableRowDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.9", type: EntityTableRowDirective, isStandalone: true, selector: "[igoEntityTableRow]", inputs: { selection: "selection", selectOnClick: "selectOnClick", highlightSelection: "highlightSelection", selected: "selected", scrollBehavior: "scrollBehavior" }, outputs: { select: "select" }, host: { listeners: { "click": "onClick()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EntityTableRowDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoEntityTableRow]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ElementRef }], propDecorators: { selection: [{
+                type: Input
+            }], selectOnClick: [{
+                type: Input
+            }], highlightSelection: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], scrollBehavior: [{
+                type: Input
+            }], select: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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