ngx-ode-ui 4.6.0-dev-produit.3 → 4.6.0-dev-integration.2

package/esm2015/lib/components/list-checkable/list-checkable.component.js

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/list-checkable/list-checkable.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ContentChild, EventEmitter, Input, Output, TemplateRef, Injector } from '@angular/core';
+export class ListCheckableComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.model = [];
+        this.noResultsLabel = 'list.results.no.items';
+        this.readOnly = false;
+        this.onCheck = new EventEmitter();
+        this.listChange = new EventEmitter();
+        this.scrolledDown = new EventEmitter();
+        this.areAllChecked = (/**
+         * @return {?}
+         */
+        () => false);
+        this.isChecked = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        (arg) => false);
+        this.isDisabled = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        (arg) => false);
+        this.ngClass = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        (arg) => ({}));
+        /* Store pipe */
+        this.self = this;
+        this._storedElements = [];
+    }
+    /**
+     * @param {?} list
+     * @return {?}
+     */
+    set storedElements(list) {
+        this._storedElements = list;
+        this.listChange.emit(list);
+    }
+    /**
+     * @return {?}
+     */
+    get storedElements() {
+        return this._storedElements;
+    }
+    /**
+     * @param {?} checkAll
+     * @return {?}
+     */
+    toggleAll(checkAll) {
+        this.model.forEach((/**
+         * @param {?} item
+         * @return {?}
+         */
+        item => {
+            /** @type {?} */
+            const isChecked = this.isChecked(item);
+            if (!this.isDisabled(item)
+                && ((isChecked && !checkAll) || (!isChecked && checkAll))) {
+                this.onCheck.emit({ item: item, checked: checkAll });
+            }
+        }));
+    }
+}
+ListCheckableComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-list-checkable',
+                template: "<div class=\"list-checkable-wrapper\"\n     infiniteScroll\n     [scrollWindow]=\"false\"\n     (scrolled)=\"scrolledDown.emit()\"\n     [infiniteScrollThrottle]=\"50\">\n\n  <ul *ngIf=\"storedElements && storedElements.length === 0\">\n    <li class=\"no-results\"><span>{{ noResultsLabel | translate }}</span></li>\n  </ul>\n  \n  <ul>\n    <li class=\"select-all\" \n        [class.checked]=\"areAllChecked()\"\n        *ngIf=\"!readOnly\">\n      <label>\n        <span>{{(areAllChecked() ? 'ux.multiselect.deselect-all' : 'ux.multiselect.select-all') | translate}}</span>\n        <input type=\"checkbox\" [checked]=\"areAllChecked()\" (change)=\"toggleAll($event.target.checked)\" />\n      </label>\n    </li>\n\n    <li class=\"lct-list-checkable-item\" \n        [class.checked]=\"isChecked(item)\"\n        [class.disabled]=\"isDisabled(item)\"\n        [ngClass]=\"ngClass(item)\"\n        *ngFor=\"let item of model | filter: filters | store:self:'storedElements' | orderBy: sort | slice: 0:limit\">\n      <label>\n        <span>\n          <ng-template [ngTemplateOutlet]=\"templateRef\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>        \n        </span>\n        <input *ngIf=\"!readOnly\" type=\"checkbox\" \n              [disabled]=\"isDisabled(item)\"\n              [checked]=\"isChecked(item)\"\n              (change)=\"onCheck.emit({item:item, checked:$event.target.checked})\"/>\n      </label>\n    </li>\n  </ul>\n\n</div>\n",
+                styles: ["ul{margin:0;padding:0;font-size:.9em}ul li{border-top:1px solid #ddd;width:-webkit-fill-available;width:-moz-available;display:flex}ul li:not(.checked){color:#939393}ul li.disabled{pointer-events:none}ul li.select-all{background-color:#ff83520a;color:#5b6472}ul li.select-all span{text-align:right}ul li label{cursor:pointer;width:100%;display:flex}ul li label:hover{background-color:#eaedf2}ul li label span{padding:7px 15px;width:100%}ul li label input[type=checkbox]{margin-right:15px;-ms-grid-row-align:center;align-self:center}"]
+            }] }
+];
+/** @nocollapse */
+ListCheckableComponent.ctorParameters = () => [
+    { type: Injector }
+];
+ListCheckableComponent.propDecorators = {
+    model: [{ type: Input }],
+    filters: [{ type: Input }],
+    sort: [{ type: Input }],
+    limit: [{ type: Input }],
+    noResultsLabel: [{ type: Input }],
+    readOnly: [{ type: Input }],
+    onCheck: [{ type: Output }],
+    listChange: [{ type: Output }],
+    scrolledDown: [{ type: Output }],
+    templateRef: [{ type: ContentChild, args: [TemplateRef, { static: false },] }],
+    areAllChecked: [{ type: Input }],
+    isChecked: [{ type: Input }],
+    isDisabled: [{ type: Input }],
+    ngClass: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    ListCheckableComponent.prototype.model;
+    /** @type {?} */
+    ListCheckableComponent.prototype.filters;
+    /** @type {?} */
+    ListCheckableComponent.prototype.sort;
+    /** @type {?} */
+    ListCheckableComponent.prototype.limit;
+    /** @type {?} */
+    ListCheckableComponent.prototype.noResultsLabel;
+    /** @type {?} */
+    ListCheckableComponent.prototype.readOnly;
+    /** @type {?} */
+    ListCheckableComponent.prototype.onCheck;
+    /** @type {?} */
+    ListCheckableComponent.prototype.listChange;
+    /** @type {?} */
+    ListCheckableComponent.prototype.scrolledDown;
+    /** @type {?} */
+    ListCheckableComponent.prototype.templateRef;
+    /** @type {?} */
+    ListCheckableComponent.prototype.areAllChecked;
+    /** @type {?} */
+    ListCheckableComponent.prototype.isChecked;
+    /** @type {?} */
+    ListCheckableComponent.prototype.isDisabled;
+    /** @type {?} */
+    ListCheckableComponent.prototype.ngClass;
+    /** @type {?} */
+    ListCheckableComponent.prototype.self;
+    /** @type {?} */
+    ListCheckableComponent.prototype._storedElements;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/message-box/message-box.component.js

@@ -0,0 +1,153 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/message-box/message-box.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { HostBinding } from '@angular/core';
+import { Component, ElementRef, EventEmitter, Input, Output, Injector } from '@angular/core';
+import { OdeComponent } from 'ngx-ode-core';
+/** @type {?} */
+export const icons = {
+    info: 'fa-question-circle',
+    warning: 'fa-exclamation-circle',
+    danger: 'fa-ban',
+    success: 'fa-check-circle'
+};
+export class MessageBoxComponent extends OdeComponent {
+    /**
+     * @param {?} eltRef
+     * @param {?} injector
+     */
+    constructor(eltRef, injector) {
+        super(injector);
+        this.eltRef = eltRef;
+        this._position = 'inherit';
+        /**
+         * `gravity` set the relative position of the message box if its position is 'absolute'.
+         * No effect when position is 'inherit'.
+         */
+        this.gravity = 'left';
+        this.hidden = false;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    set messages(value) {
+        this._messages = [];
+        for (const message of value) {
+            if (typeof message == 'string') {
+                this._messages.push([message, {}]);
+            }
+            else if (typeof message == 'object') {
+                this._messages.push(message);
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    get messages() {
+        return this._messages;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    set position(value) {
+        this._position = value;
+    }
+    /**
+     * @return {?}
+     */
+    get isGravityLeft() { return this.gravity === 'left'; }
+    /**
+     * @return {?}
+     */
+    get isGravityRight() { return this.gravity === 'right'; }
+    /**
+     * @return {?}
+     */
+    canHide() {
+        if (this._position == 'absolute') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @return {?}
+     */
+    hide() {
+        this.hidden = true;
+        this.hideEvent.emit();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        if (this.type == undefined) {
+            throw new Error('MessageSticker : type\' property must be set');
+        }
+        this.eltRef.nativeElement.style.position = this._position;
+        if (this._position == 'absolute') {
+            this.eltRef.nativeElement.style.width = '450px';
+            // TODO: Maybe use a static counter to push on top the last open MessageBox ?
+            this.eltRef.nativeElement.style.zIndex = '10';
+        }
+    }
+}
+MessageBoxComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'message-box',
+                template: "<article class=\"message is-{{type}}\" [hidden]=\"hidden\">\n  <div *ngIf=\"header\" class=\"message-header\">\n    <p>\n      <i *ngIf=\"canHide()\" (click)=\"hide()\" class=\"fa fa-times-circle\"></i>\n      {{header | translate}}\n    </p>\n  </div>\n  <div class=\"message-body\">\n    <i *ngIf=\"canHide() && !header\" (click)=\"hide()\" class=\"fa fa-times-circle\"></i>\n    <p *ngFor=\"let message of messages\">\n      <s5l [s5l-params]=\"message[1]\">{{message[0]}}</s5l>\n    </p>\n  </div>\n</article>\n",
+                styles: [":host{font-size:initial;position:inherit;top:-5px}:host.gravity-left{right:-5px}:host.gravity-right{left:-5px}:host .message{border:1px solid}i.fa-times-circle{display:inline-flex;float:right;cursor:pointer;font-weight:700}"]
+            }] }
+];
+/** @nocollapse */
+MessageBoxComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Injector }
+];
+MessageBoxComponent.propDecorators = {
+    type: [{ type: Input }],
+    header: [{ type: Input }],
+    messages: [{ type: Input }],
+    position: [{ type: Input }],
+    gravity: [{ type: Input }],
+    isGravityLeft: [{ type: HostBinding, args: ['class.gravity-left',] }],
+    isGravityRight: [{ type: HostBinding, args: ['class.gravity-right',] }],
+    hideEvent: [{ type: Output, args: ['onHide',] }]
+};
+if (false) {
+    /** @type {?} */
+    MessageBoxComponent.prototype.type;
+    /** @type {?} */
+    MessageBoxComponent.prototype.header;
+    /**
+     * @type {?}
+     * @private
+     */
+    MessageBoxComponent.prototype._messages;
+    /**
+     * @type {?}
+     * @private
+     */
+    MessageBoxComponent.prototype._position;
+    /**
+     * `gravity` set the relative position of the message box if its position is 'absolute'.
+     * No effect when position is 'inherit'.
+     * @type {?}
+     */
+    MessageBoxComponent.prototype.gravity;
+    /** @type {?} */
+    MessageBoxComponent.prototype.hidden;
+    /** @type {?} */
+    MessageBoxComponent.prototype.hideEvent;
+    /**
+     * @type {?}
+     * @private
+     */
+    MessageBoxComponent.prototype.eltRef;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/message-sticker/message-sticker.component.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/message-sticker/message-sticker.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, EventEmitter, Input, ViewChild, Injector } from '@angular/core';
+import { icons, MessageBoxComponent } from '../message-box/message-box.component';
+import { DynamicComponentDirective } from '../../directives/dynamic-component/dynamic-component.directive';
+import { ComponentDescriptor } from '../../directives/dynamic-component/component-descriptor.model';
+export class MessageStickerComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.gravity = 'left';
+        this.icons = icons;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        if (this.type === undefined) {
+            throw new Error('MessageSticker : type\' property must be set');
+        }
+    }
+    /**
+     * @return {?}
+     */
+    newMessageBox() {
+        return new ComponentDescriptor(MessageBoxComponent, {
+            type: this.type,
+            header: this.header,
+            messages: this.messages,
+            position: 'absolute',
+            gravity: this.gravity,
+            hideEvent: new EventEmitter()
+        });
+    }
+    /**
+     * @return {?}
+     */
+    loadMessageBox() {
+        this.dComponent.load();
+    }
+}
+MessageStickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-message-sticker',
+                template: "<i (click)=\"loadMessageBox()\" class=\"fa {{icons[type]}} is-{{type}}\"></i>\n<span message-box-anchor>\n            <ng-container [dynamic-component]=\"newMessageBox()\"></ng-container>\n        </span>\n",
+                styles: [":host{display:inline;padding-left:.2em}span[message-box-anchor]{position:absolute;z-index:8}i{cursor:pointer}"]
+            }] }
+];
+/** @nocollapse */
+MessageStickerComponent.ctorParameters = () => [
+    { type: Injector }
+];
+MessageStickerComponent.propDecorators = {
+    type: [{ type: Input }],
+    header: [{ type: Input }],
+    messages: [{ type: Input }],
+    gravity: [{ type: Input }],
+    dComponent: [{ type: ViewChild, args: [DynamicComponentDirective, { static: false },] }]
+};
+if (false) {
+    /** @type {?} */
+    MessageStickerComponent.prototype.type;
+    /** @type {?} */
+    MessageStickerComponent.prototype.header;
+    /** @type {?} */
+    MessageStickerComponent.prototype.messages;
+    /** @type {?} */
+    MessageStickerComponent.prototype.gravity;
+    /** @type {?} */
+    MessageStickerComponent.prototype.dComponent;
+    /** @type {?} */
+    MessageStickerComponent.prototype.icons;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/mono-select/mono-select.component.js

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/mono-select/mono-select.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, ElementRef, forwardRef, Input, Injector } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { OdeComponent } from 'ngx-ode-core';
+/**
+ * @template K
+ */
+export class MonoSelectComponent extends OdeComponent {
+    /**
+     * @param {?} elementRef
+     * @param {?} injector
+     */
+    constructor(elementRef, injector) {
+        super(injector);
+        this.elementRef = elementRef;
+        this.placeholder = 'monoselect.placeholder.default';
+        this.options = [];
+        this.translateOptions = true;
+        this.opened = false;
+        this.selectedOption = null;
+        this.disabled = false;
+        this.onChange = (/**
+         * @param {?} _
+         * @return {?}
+         */
+        (_) => {
+        });
+        this.onTouched = (/**
+         * @return {?}
+         */
+        () => {
+        });
+    }
+    /**
+     * @param {?=} option
+     * @return {?}
+     */
+    optionClicked(option) {
+        this.selectedOption = option;
+        this.opened = false;
+        this.onChange(this.selectedOption != null ? this.selectedOption.value : null);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onClickOnDocument(event) {
+        if (this.opened &&
+            !this.elementRef.nativeElement.querySelector('.lct-form-select').contains(event.target)) {
+            this.opened = false;
+        }
+        return true;
+    }
+    /**
+     * @return {?}
+     */
+    onClickOnHost() {
+        if (!this.opened && !this.disabled) {
+            this.opened = true;
+        }
+        else {
+            this.opened = false;
+        }
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     * @param {?} obj
+     * @return {?}
+     */
+    writeValue(obj) {
+        this.selectedOption = this.options.find((/**
+         * @param {?} option
+         * @return {?}
+         */
+        option => option.value === obj));
+        this.onChange(this.selectedOption ? this.selectedOption.value : null);
+    }
+}
+MonoSelectComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-mono-select',
+                template: "<div class=\"form-select lct-form-select\" [ngClass]=\"{'form-select--opened': opened, 'form-select--disabled': disabled}\">\n  <ul>\n    <li class=\"form-select__options--selected lct-form-select__options--selected\">\n      <strong>{{selectedOption ? ((translateOptions == true) ? (selectedOption.label | translate) : selectedOption.label) : (placeholder | translate)}}</strong>\n      <ul class=\"form-select__list lct-form-select__list\" *ngIf=\"opened\">\n        <li class=\"form-select__options lct-form-select__options\"\n            (click)=\"$event.stopPropagation(); optionClicked()\">{{placeholder | translate}}</li>\n        <li class=\"form-select__options lct-form-select__options\"\n            *ngFor=\"let option of options\"\n            (click)=\"$event.stopPropagation(); optionClicked(option)\">{{(translateOptions == true) ? (option.label | translate) : option.label}}</li>\n      </ul>\n    </li>\n  </ul>\n</div>\n",
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef((/**
+                         * @return {?}
+                         */
+                        () => MonoSelectComponent)),
+                        multi: true
+                    }],
+                host: {
+                    '(document:click)': 'onClickOnDocument($event)',
+                    '(click)': 'onClickOnHost()'
+                }
+            }] }
+];
+/** @nocollapse */
+MonoSelectComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Injector }
+];
+MonoSelectComponent.propDecorators = {
+    placeholder: [{ type: Input }],
+    options: [{ type: Input }],
+    trackByFn: [{ type: Input }],
+    translateOptions: [{ type: Input }],
+    disabled: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    MonoSelectComponent.prototype.placeholder;
+    /** @type {?} */
+    MonoSelectComponent.prototype.options;
+    /** @type {?} */
+    MonoSelectComponent.prototype.trackByFn;
+    /** @type {?} */
+    MonoSelectComponent.prototype.translateOptions;
+    /** @type {?} */
+    MonoSelectComponent.prototype.opened;
+    /** @type {?} */
+    MonoSelectComponent.prototype.selectedOption;
+    /** @type {?} */
+    MonoSelectComponent.prototype.disabled;
+    /**
+     * @type {?}
+     * @private
+     */
+    MonoSelectComponent.prototype.onChange;
+    /**
+     * @type {?}
+     * @private
+     */
+    MonoSelectComponent.prototype.onTouched;
+    /**
+     * @type {?}
+     * @private
+     */
+    MonoSelectComponent.prototype.elementRef;
+}
+//# sourceMappingURL=data:application/json;base64,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