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

package/esm2015/lib/components/tooltip/tooltip.component.js

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/tooltip/tooltip.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, Input, Renderer2, Injector } from '@angular/core';
+export class TooltipComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     * @param {?} ref
+     * @param {?} renderer
+     */
+    constructor(injector, ref, renderer) {
+        super(injector);
+        this.ref = ref;
+        this.renderer = renderer;
+        this.position = 'bottom';
+        this.offset = 5;
+        this.onTransitionEnd = (/**
+         * @return {?}
+         */
+        () => {
+            if (this.tooltipElt && !this.tooltipElt.classList.contains('shown')) {
+                this.tooltipElt.parentNode.removeChild(this.tooltipElt);
+                this.tooltipElt = null;
+            }
+        });
+    }
+    /**
+     * @return {?}
+     */
+    onMouseEnter() {
+        /** @type {?} */
+        const r = this.renderer;
+        if (!this.tooltipElt) {
+            this.tooltipElt = this.renderer.createElement('div');
+            /** @type {?} */
+            let tooltipText = this.renderer.createText(this.tooltipContents);
+            this.renderer.appendChild(this.tooltipElt, tooltipText);
+            this.renderer.addClass(this.tooltipElt, "tooltip");
+            this.renderer.appendChild(document.getElementsByTagName('body')[0], this.tooltipElt);
+        }
+        /** @type {?} */
+        const tip = this.tooltipElt;
+        /** @type {?} */
+        const pos = this.getPosition(this.ref.nativeElement, tip, this.position);
+        for (const prop in pos) {
+            this.renderer.setStyle(tip, prop, pos[prop] + 'px');
+        }
+        this.renderer.addClass(tip, 'shown');
+    }
+    /**
+     * @return {?}
+     */
+    onMouseLeave() {
+        /** @type {?} */
+        const wait = this.tooltipElt &&
+            parseFloat(window.getComputedStyle(this.tooltipElt)['transition-duration']);
+        this.renderer.removeClass(this.tooltipElt, 'shown');
+        setTimeout(this.onTransitionEnd, wait * 1000);
+    }
+    /**
+     * @private
+     * @param {?} elt
+     * @param {?} tip
+     * @param {?} pos
+     * @return {?}
+     */
+    getPosition(elt, tip, pos) {
+        /** @type {?} */
+        const rect = {
+            top: elt.getBoundingClientRect().top + window.scrollY,
+            left: elt.getBoundingClientRect().left + window.scrollX
+        };
+        /** @type {?} */
+        let left;
+        /** @type {?} */
+        let top;
+        switch (pos) {
+            case 'top':
+                top = rect.top - tip.offsetHeight - this.offset;
+                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;
+                break;
+            case 'left':
+                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;
+                left = rect.left - tip.offsetWidth - this.offset;
+                break;
+            case 'right':
+                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;
+                left = rect.left + elt.offsetWidth + this.offset;
+                break;
+            case 'bottom':
+            default:
+                top = rect.top + elt.offsetHeight + this.offset;
+                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;
+        }
+        if (left < 0) {
+            left = rect.left + elt.offsetWidth + this.offset;
+        }
+        if (top < 0) {
+            top = rect.top + elt.offsetHeight + this.offset;
+        }
+        if (left + tip.offsetWidth >= window.pageXOffset + window.innerWidth) {
+            left = rect.left - tip.offsetWidth - this.offset;
+        }
+        if (top - tip.offsetHeight >= window.pageYOffset + window.innerHeight) {
+            top = rect.top - tip.offsetHeight - this.offset;
+        }
+        return {
+            top: top < 5 ? 5 : top,
+            left: left < 5 ? 5 : left
+        };
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        if (this.tooltipElt) {
+            this.tooltipElt.parentNode.removeChild(this.tooltipElt);
+            this.tooltipElt = null;
+        }
+    }
+}
+TooltipComponent.decorators = [
+    { type: Component, args: [{
+                selector: '[tooltip]',
+                template: `<ng-content></ng-content>`,
+                host: {
+                    '(mouseenter)': 'onMouseEnter()',
+                    '(mouseleave)': 'onMouseLeave()'
+                },
+                styles: ["body>div.tooltip{position:absolute;z-index:100}"]
+            }] }
+];
+/** @nocollapse */
+TooltipComponent.ctorParameters = () => [
+    { type: Injector },
+    { type: ElementRef },
+    { type: Renderer2 }
+];
+TooltipComponent.propDecorators = {
+    tooltipContents: [{ type: Input, args: ['tooltip',] }],
+    position: [{ type: Input }],
+    offset: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    TooltipComponent.prototype.tooltipContents;
+    /** @type {?} */
+    TooltipComponent.prototype.position;
+    /** @type {?} */
+    TooltipComponent.prototype.offset;
+    /**
+     * @type {?}
+     * @private
+     */
+    TooltipComponent.prototype.tooltipElt;
+    /** @type {?} */
+    TooltipComponent.prototype.onTransitionEnd;
+    /**
+     * @type {?}
+     * @private
+     */
+    TooltipComponent.prototype.ref;
+    /**
+     * @type {?}
+     * @private
+     */
+    TooltipComponent.prototype.renderer;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/tooltip/tooltip.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport { Component, ElementRef, Input, Renderer2, Injector } from '@angular/core';\n\n@Component({\n    selector: '[tooltip]',\n    template: `<ng-content></ng-content>`,\n    styleUrls: ['./tooltip.component.scss'],\n    host: {\n        '(mouseenter)': 'onMouseEnter()',\n        '(mouseleave)': 'onMouseLeave()'\n    }\n})\nexport class TooltipComponent extends OdeComponent {\n\n    constructor(injector: Injector,\n                private ref: ElementRef,\n                private renderer: Renderer2) {\n                    super(injector);\n                }\n\n    @Input('tooltip') tooltipContents: string;\n    @Input() position: 'top' | 'left' | 'right' | 'bottom' = 'bottom';\n    @Input() offset = 5;\n\n    private tooltipElt: HTMLElement;\n\n    onMouseEnter(): void {\n        const r = this.renderer;\n\n        if (!this.tooltipElt) {\n            this.tooltipElt = this.renderer.createElement('div');\n            let tooltipText = this.renderer.createText(this.tooltipContents);\n            this.renderer.appendChild(this.tooltipElt, tooltipText);\n            this.renderer.addClass(this.tooltipElt, \"tooltip\");\n            this.renderer.appendChild(document.getElementsByTagName('body')[0], this.tooltipElt);\n        }\n        const tip = this.tooltipElt;\n        const pos = this.getPosition(this.ref.nativeElement, tip, this.position);\n        for (const prop in pos) {\n            this.renderer.setStyle(tip, prop, pos[prop] + 'px');\n        }\n        this.renderer.addClass(tip, 'shown');\n    }\n\n    onMouseLeave(): void {\n        const wait = this.tooltipElt &&\n            parseFloat(window.getComputedStyle(this.tooltipElt)['transition-duration']);\n        this.renderer.removeClass(this.tooltipElt, 'shown');\n        setTimeout(this.onTransitionEnd, wait * 1000);\n    }\n\n    onTransitionEnd = () => {\n        if (this.tooltipElt && !this.tooltipElt.classList.contains('shown')) {\n            this.tooltipElt.parentNode.removeChild(this.tooltipElt);\n            this.tooltipElt = null;\n        }\n    }\n\n    private getPosition(elt, tip, pos) {\n        const rect = {\n            top: elt.getBoundingClientRect().top + window.scrollY,\n            left: elt.getBoundingClientRect().left + window.scrollX\n        };\n        let left, top;\n\n        switch (pos) {\n\n            case 'top':\n                top = rect.top - tip.offsetHeight - this.offset;\n                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;\n                break;\n            case 'left':\n                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;\n                left = rect.left - tip.offsetWidth - this.offset;\n                break;\n            case 'right':\n                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;\n                left = rect.left + elt.offsetWidth + this.offset;\n                break;\n            case 'bottom':\n            default:\n                top = rect.top + elt.offsetHeight + this.offset;\n                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;\n        }\n\n        if (left < 0 ) {\n            left = rect.left + elt.offsetWidth + this.offset;\n        }\n        if (top < 0) {\n            top = rect.top + elt.offsetHeight + this.offset;\n        }\n        if (left + tip.offsetWidth >= window.pageXOffset + window.innerWidth) {\n            left = rect.left - tip.offsetWidth - this.offset;\n        }\n        if (top - tip.offsetHeight >= window.pageYOffset + window.innerHeight) {\n            top = rect.top - tip.offsetHeight - this.offset;\n        }\n\n        return {\n            top: top < 5 ? 5 : top,\n            left: left < 5 ? 5 : left\n        };\n    }\n\n    ngOnDestroy(): void {\n        if (this.tooltipElt) {\n            this.tooltipElt.parentNode.removeChild(this.tooltipElt);\n            this.tooltipElt = null;\n        }\n    }\n\n}\n"]}

package/esm2015/lib/components/upload-files/upload-files.component.js

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/upload-files/upload-files.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild, Injector } from '@angular/core';
+import { InputFileService } from '../../services/inputFile.service';
+export class UploadFilesComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     * @param {?} inputFileService
+     */
+    constructor(injector, inputFileService) {
+        super(injector);
+        this.inputFileService = inputFileService;
+        this.upload = new EventEmitter();
+        this.invalidUpload = new EventEmitter();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        this.multiple = this.maxFilesNumber > 1;
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    onChange($event) {
+        if ($event.target) {
+            this.inputFileService
+                .validateFiles($event.target.files, this.maxFilesNumber, this.allowedExtensions)
+                .subscribe((/**
+             * @param {?} files
+             * @return {?}
+             */
+            files => this.upload.emit(files)), (/**
+             * @param {?} error
+             * @return {?}
+             */
+            error => this.invalidUpload.emit(error)));
+        }
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    onClickDropzoneInput($event) {
+        $event.stopPropagation();
+        /** @type {?} */
+        const inputFileElement = this.inputFileRef.nativeElement;
+        inputFileElement.click();
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    onDragAndDrop($event) {
+        this.upload.emit($event);
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    onInvalidDragAndDrop($event) {
+        this.invalidUpload.emit($event);
+    }
+}
+UploadFilesComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-upload-files',
+                template: "<div class=\"upload-files-dropzone\"\n     dragAndDropFiles\n     [allowedExtensions]=\"allowedExtensions\"\n     [maxFilesNumber]=\"maxFilesNumber\"\n     [disabled]=\"disabled\"\n     (dragAndDrop)=\"onDragAndDrop($event)\"\n     (invalidDragAndDrop)=\"onInvalidDragAndDrop($event)\">\n  <div *ngIf=\"fileSrc\" class=\"upload-files-dropzone-image\">\n    <img src=\"{{ fileSrc }}\"\n         *ngIf=\"inputFileService.isSrcExternalUrl(fileSrc)\"\n         class=\"upload-files-dropzone-image__image\"/>\n    <img src=\"{{ fileSrc }}\"\n         *ngIf=\"inputFileService.isSrcWorkspace(fileSrc)\"\n         class=\"upload-files-dropzone-image__image\"/>\n    <i class=\"upload-files-dropzone-image__icon {{ fileSrc }}\"\n       *ngIf=\"!inputFileService.isSrcExternalUrl(fileSrc)\n                        && !inputFileService.isSrcWorkspace(fileSrc)\"></i>\n  </div>\n\n  <div class=\"upload-files-dropzone-input\" *ngIf=\"!disabled\">\n    <button class=\"confirm upload-files-dropzone-input__button\"\n            (click)=\"onClickDropzoneInput($event)\">\n      <s5l>ux.upload-files.button.label</s5l>\n    </button>\n    <i class=\"upload-files-dropzone-input__icon fa fa-cloud-upload fa-2x\">\n    </i>\n    <span class=\"upload-files-dropzone-input__help\">\n                    <s5l>ux.upload-files.button.help</s5l>\n                </span>\n    <input *ngIf=\"multiple === true else singleFileInput\"\n           class=\"upload-files-dropzone-input__input\"\n           type=\"file\"\n           (change)=\"onChange($event)\"\n           multiple\n           #inputFileRef>\n    <ng-template #singleFileInput>\n      <input class=\"upload-files-dropzone-input__input\"\n             type=\"file\"\n             (change)=\"onChange($event)\"\n             #inputFileRef>\n    </ng-template>\n  </div>\n</div>\n",
+                styles: [".upload-files-dropzone{display:flex;align-items:center;justify-content:center;min-height:150px;margin:20px;padding:20px 10px;background-color:#fafafa;border:2px dashed #ddd;border-radius:5px}.upload-files-dropzone-image{display:flex;align-items:center;justify-content:center;width:120px;height:120px}.upload-files-dropzone-image__image{max-height:90%;max-width:90%}.upload-files-dropzone-image__icon{font-size:5em}.upload-files-dropzone-input{display:flex;align-items:center;background-color:#fff;border-radius:5px;box-shadow:1px 1px 5px rgba(0,0,0,.3);padding:10px;margin:0 40px 0 20px}.upload-files-dropzone-input__input{display:none}.upload-files-dropzone-input__icon{margin-left:10px}.upload-files-dropzone-input__help{margin-left:10px;font-style:italic}"]
+            }] }
+];
+/** @nocollapse */
+UploadFilesComponent.ctorParameters = () => [
+    { type: Injector },
+    { type: InputFileService }
+];
+UploadFilesComponent.propDecorators = {
+    fileSrc: [{ type: Input }],
+    allowedExtensions: [{ type: Input }],
+    maxFilesNumber: [{ type: Input }],
+    disabled: [{ type: Input }],
+    upload: [{ type: Output }],
+    invalidUpload: [{ type: Output }],
+    inputFileRef: [{ type: ViewChild, args: ['inputFileRef', { static: false },] }]
+};
+if (false) {
+    /** @type {?} */
+    UploadFilesComponent.prototype.fileSrc;
+    /** @type {?} */
+    UploadFilesComponent.prototype.allowedExtensions;
+    /** @type {?} */
+    UploadFilesComponent.prototype.maxFilesNumber;
+    /** @type {?} */
+    UploadFilesComponent.prototype.disabled;
+    /** @type {?} */
+    UploadFilesComponent.prototype.upload;
+    /** @type {?} */
+    UploadFilesComponent.prototype.invalidUpload;
+    /** @type {?} */
+    UploadFilesComponent.prototype.inputFileRef;
+    /** @type {?} */
+    UploadFilesComponent.prototype.multiple;
+    /** @type {?} */
+    UploadFilesComponent.prototype.inputFileService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/value-editable/simple-select.component.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/value-editable/simple-select.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, Injector } from '@angular/core';
+/**
+ * @record
+ */
+export function Option() { }
+if (false) {
+    /** @type {?} */
+    Option.prototype.value;
+    /** @type {?} */
+    Option.prototype.label;
+}
+export class SimpleSelectComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.selectChange = new EventEmitter();
+    }
+}
+SimpleSelectComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-simple-select',
+                template: "<select [ngModel]=\"model[selected]\" (ngModelChange)=\"model[selected] = $event; selectChange.emit($event)\">\n\n<option *ngIf=\"ignoreOption.length > 0 \" [ngValue]=\"ignoreOption[0].value\">\n                                                                          {{ignoreOption[0].label}}\n</option>\n<option *ngFor=\"let option of options | orderBy: 'label'\" [ngValue]=\"option.value\">\n                                                                                  {{option.label}}\n</option>\n</select>\n",
+                changeDetection: ChangeDetectionStrategy.OnPush
+            }] }
+];
+/** @nocollapse */
+SimpleSelectComponent.ctorParameters = () => [
+    { type: Injector }
+];
+SimpleSelectComponent.propDecorators = {
+    selected: [{ type: Input }],
+    model: [{ type: Input }],
+    options: [{ type: Input }],
+    ignoreOption: [{ type: Input }],
+    selectChange: [{ type: Output }]
+};
+if (false) {
+    /** @type {?} */
+    SimpleSelectComponent.prototype.selected;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.model;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.options;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.ignoreOption;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.selectChange;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/wizard/wizard.component.js

@@ -0,0 +1,225 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/wizard/wizard.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ContentChildren, EventEmitter, Input, Output, QueryList, Injector } from '@angular/core';
+export class StepComponent {
+    constructor() {
+        this.hasError = false;
+        this.isFinished = false;
+    }
+}
+StepComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-step',
+                template: `<ng-content></ng-content>`,
+                styles: [`
+        :host {
+            display: none;
+            overflow: auto;
+            padding : 1em;
+        }
+        :host.active {
+            display: block;
+        }
+    `]
+            }] }
+];
+StepComponent.propDecorators = {
+    name: [{ type: Input }],
+    isActived: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    StepComponent.prototype.name;
+    /** @type {?} */
+    StepComponent.prototype.isActived;
+    /** @type {?} */
+    StepComponent.prototype.hasError;
+    /** @type {?} */
+    StepComponent.prototype.isFinished;
+}
+export class WizardComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.cancel = new EventEmitter();
+        this.previousStep = new EventEmitter();
+        this.nextStep = new EventEmitter();
+        this.canDoNext = true;
+        this.activeStep = 0;
+    }
+    /**
+     * @return {?}
+     */
+    doCancel() {
+        this.activeStep = 0;
+        this.steps.forEach((/**
+         * @param {?} step
+         * @param {?} index
+         * @return {?}
+         */
+        (step, index) => {
+            index === 0 ? step.isActived = true : step.isActived = false;
+        }));
+        this.canDoNext = true;
+    }
+    /**
+     * @return {?}
+     */
+    onPreviousStep() {
+        this.previousStep.emit(this.activeStep);
+    }
+    /**
+     * @return {?}
+     */
+    doPreviousStep() {
+        if (this.activeStep > 0) {
+            this.steps.toArray()[this.activeStep].isActived = false;
+            this.steps.toArray()[this.activeStep - 1].isActived = true;
+            this.activeStep--;
+            this.canDoNext = true;
+        }
+    }
+    /**
+     * @return {?}
+     */
+    onNextStep() {
+        this.nextStep.emit(this.activeStep);
+    }
+    /**
+     * @param {?=} error
+     * @return {?}
+     */
+    doNextStep(error) {
+        if (this.activeStep < this.steps.length - 1) {
+            this.canDoNext = !error;
+            this.steps.toArray()[this.activeStep].isActived = false;
+            this.steps.toArray()[this.activeStep + 1].isActived = true;
+            this.activeStep++;
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+        if (this.steps.length === 0) {
+            throw new Error('<wizard> component musts nest at least 1 <step> compoent');
+        }
+    }
+}
+WizardComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-wizard',
+                template: `
+        <div class="wizard">
+            <nav class="wizard-menu">
+                <h2 class="wizard-menu__title"><s5l>wizard.steps</s5l></h2>
+                <ul>
+                    <li *ngFor="let step of steps"
+                        [class.active]="step.isActived"
+                        [class.finish]="step.isFinished">
+                        {{step.name}}
+                    </li>
+                </ul>
+            </nav>
+            <section class="wizard-content">
+                <ng-content select="ode-step"></ng-content>
+                <nav class="wizard-content-nav" *ngIf="activeStep < steps.length - 1">
+                    <button class="wizard-content-nav__button cancel"
+                        (click)="cancel.emit()"
+                        [title]="'cancel' | translate">
+                        {{ 'cancel' | translate }}
+                    </button>
+                    <button class="wizard-content-nav__button previous"
+                        (click)="onPreviousStep()"
+                        *ngIf="activeStep > 0"
+                        [title]="'previous' | translate">
+                        {{ 'wizard.previous' | translate }}
+                    </button>
+                    <button class="wizard-content-nav__button wizard-content-nav__button--next"
+                        (click)="onNextStep()"
+                        [disabled]="!canDoNext"
+                        [title]="'next' | translate">
+                        {{ 'wizard.next' | translate }}
+                    </button>
+                </nav>
+            </section>
+        </div>
+    `,
+                styles: [`
+        .wizard {
+            display: flex;
+        }
+        .wizard-menu {
+            background: #5b6472;
+            flex: 0 0 240px;
+        }
+        .wizard-menu ul {
+            padding: 10px 30px;
+        }
+        .wizard-menu ul li {
+            color: #eaedf2;
+            list-style-type: none;
+            padding: 5px 0;
+        }
+        .wizard-menu ul li.active,
+        .wizard-menu ul li.finish {
+            font-weight: bold;
+            color: white;
+        }
+        .wizard-menu ul li.finish {
+            color: green;
+        }
+        .wizard-menu__title {
+            font-weight: bold;
+            font-size: 1.2em;
+            color: white;
+            padding: 25px 0 0 10px;
+        }
+        .wizard-content {
+            background: #fff;
+            flex: auto;
+        }
+        .wizard-content-nav {
+            text-align : right;
+        }
+        .wizard-content-nav__button {
+            margin: 10px 0;
+        }
+        .wizard-content-nav__button--next {
+            margin-right: 16px;
+        }
+    `]
+            }] }
+];
+/** @nocollapse */
+WizardComponent.ctorParameters = () => [
+    { type: Injector }
+];
+WizardComponent.propDecorators = {
+    cancel: [{ type: Output }],
+    previousStep: [{ type: Output }],
+    nextStep: [{ type: Output }],
+    steps: [{ type: ContentChildren, args: [StepComponent,] }]
+};
+if (false) {
+    /** @type {?} */
+    WizardComponent.prototype.cancel;
+    /** @type {?} */
+    WizardComponent.prototype.previousStep;
+    /** @type {?} */
+    WizardComponent.prototype.nextStep;
+    /** @type {?} */
+    WizardComponent.prototype.canDoNext;
+    /** @type {?} */
+    WizardComponent.prototype.steps;
+    /** @type {?} */
+    WizardComponent.prototype.activeStep;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/wizard/wizard.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport {\n  AfterContentInit,\n  Component,\n  ContentChildren,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  Injector\n} from '@angular/core';\n\n@Component({\n    selector : 'ode-step',\n    template: `<ng-content></ng-content>`,\n    styles: [`\n        :host {\n            display: none;\n            overflow: auto;\n            padding : 1em;\n        }\n        :host.active {\n            display: block;\n        }\n    `]\n})\nexport class StepComponent {\n    @Input() name: string;\n    @Input() isActived: boolean;\n    hasError = false;\n    isFinished = false;\n}\n\n@Component({\n    selector: 'ode-wizard',\n    template: `\n        <div class=\"wizard\">\n            <nav class=\"wizard-menu\">\n                <h2 class=\"wizard-menu__title\"><s5l>wizard.steps</s5l></h2>\n                <ul>\n                    <li *ngFor=\"let step of steps\"\n                        [class.active]=\"step.isActived\"\n                        [class.finish]=\"step.isFinished\">\n                        {{step.name}}\n                    </li>\n                </ul>\n            </nav>\n            <section class=\"wizard-content\">\n                <ng-content select=\"ode-step\"></ng-content>\n                <nav class=\"wizard-content-nav\" *ngIf=\"activeStep < steps.length - 1\">\n                    <button class=\"wizard-content-nav__button cancel\"\n                        (click)=\"cancel.emit()\"\n                        [title]=\"'cancel' | translate\">\n                        {{ 'cancel' | translate }}\n                    </button>\n                    <button class=\"wizard-content-nav__button previous\"\n                        (click)=\"onPreviousStep()\"\n                        *ngIf=\"activeStep > 0\"\n                        [title]=\"'previous' | translate\">\n                        {{ 'wizard.previous' | translate }}\n                    </button>\n                    <button class=\"wizard-content-nav__button wizard-content-nav__button--next\"\n                        (click)=\"onNextStep()\"\n                        [disabled]=\"!canDoNext\"\n                        [title]=\"'next' | translate\">\n                        {{ 'wizard.next' | translate }}\n                    </button>\n                </nav>\n            </section>\n        </div>\n    `,\n    styles: [`\n        .wizard {\n            display: flex;\n        }\n        .wizard-menu {\n            background: #5b6472;\n            flex: 0 0 240px;\n        }\n        .wizard-menu ul {\n            padding: 10px 30px;\n        }\n        .wizard-menu ul li {\n            color: #eaedf2;\n            list-style-type: none;\n            padding: 5px 0;\n        }\n        .wizard-menu ul li.active,\n        .wizard-menu ul li.finish {\n            font-weight: bold;\n            color: white;\n        }\n        .wizard-menu ul li.finish {\n            color: green;\n        }\n        .wizard-menu__title {\n            font-weight: bold;\n            font-size: 1.2em;\n            color: white;\n            padding: 25px 0 0 10px;\n        }\n        .wizard-content {\n            background: #fff;\n            flex: auto;\n        }\n        .wizard-content-nav {\n            text-align : right;\n        }\n        .wizard-content-nav__button {\n            margin: 10px 0;\n        }\n        .wizard-content-nav__button--next {\n            margin-right: 16px;\n        }\n    `]\n})\nexport class WizardComponent extends OdeComponent implements AfterContentInit {\n    @Output() cancel: EventEmitter<{}> = new EventEmitter();\n    @Output() previousStep: EventEmitter<number> = new EventEmitter();\n    @Output() nextStep: EventEmitter<number> = new EventEmitter();\n\n    public canDoNext = true;\n\n    @ContentChildren(StepComponent) steps: QueryList<StepComponent>;\n    activeStep = 0;\n\n    constructor(injector: Injector) {\n        super(injector);\n    }\n    doCancel() {\n        this.activeStep = 0;\n        this.steps.forEach((step, index) => {\n            index === 0 ? step.isActived = true : step.isActived = false;\n        });\n        this.canDoNext = true;\n    }\n\n    onPreviousStep() {\n        this.previousStep.emit(this.activeStep);\n    }\n\n    doPreviousStep() {\n        if (this.activeStep > 0) {\n            this.steps.toArray()[this.activeStep].isActived = false;\n            this.steps.toArray()[this.activeStep - 1].isActived = true;\n            this.activeStep--;\n            this.canDoNext = true;\n        }\n    }\n\n    onNextStep() {\n        this.nextStep.emit(this.activeStep);\n    }\n    doNextStep(error?: boolean) {\n        if (this.activeStep < this.steps.length - 1) {\n            this.canDoNext = !error;\n            this.steps.toArray()[this.activeStep].isActived = false;\n            this.steps.toArray()[this.activeStep + 1].isActived = true;\n            this.activeStep++;\n        }\n    }\n\n    ngAfterContentInit() {\n        super.ngAfterContentInit();\n        if (this.steps.length === 0) {\n            throw new Error('<wizard> component musts nest at least 1 <step> compoent');\n        }\n    }\n\n}\n"]}

package/esm2015/lib/directives/anchor.directive.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/directives/anchor.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Directive, HostListener, Input } from '@angular/core';
+export class AnchorDirective {
+    constructor() {
+        this.offset = 50;
+    }
+    /**
+     * @return {?}
+     */
+    onClick() {
+        /** @type {?} */
+        const element = document.getElementById(this.anchor);
+        window.scrollBy(0, element.getBoundingClientRect().top - this.offset);
+    }
+}
+AnchorDirective.decorators = [
+    { type: Directive, args: [{ selector: '[anchor]' },] }
+];
+AnchorDirective.propDecorators = {
+    anchor: [{ type: Input, args: ['anchor',] }],
+    offset: [{ type: Input, args: ['offset',] }],
+    onClick: [{ type: HostListener, args: ['click',] }]
+};
+if (false) {
+    /** @type {?} */
+    AnchorDirective.prototype.anchor;
+    /** @type {?} */
+    AnchorDirective.prototype.offset;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5jaG9yLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1vZGUtdWkvIiwic291cmNlcyI6WyJsaWIvZGlyZWN0aXZlcy9hbmNob3IuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRzdELE1BQU0sT0FBTyxlQUFlO0lBRDVCO1FBSXFCLFdBQU0sR0FBRyxFQUFFLENBQUM7SUFRakMsQ0FBQzs7OztJQUxHLE9BQU87O2NBQ0csT0FBTyxHQUFHLFFBQVEsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUNwRCxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsRUFBRSxPQUFPLENBQUMscUJBQXFCLEVBQUUsQ0FBQyxHQUFHLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzFFLENBQUM7OztZQVZKLFNBQVMsU0FBQyxFQUFFLFFBQVEsRUFBRSxVQUFVLEVBQUU7OztxQkFHOUIsS0FBSyxTQUFDLFFBQVE7cUJBQ2QsS0FBSyxTQUFDLFFBQVE7c0JBRWQsWUFBWSxTQUFDLE9BQU87Ozs7SUFIckIsaUNBQWdDOztJQUNoQyxpQ0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSG9zdExpc3RlbmVyLCBJbnB1dH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoeyBzZWxlY3RvcjogJ1thbmNob3JdJyB9KVxuZXhwb3J0IGNsYXNzIEFuY2hvckRpcmVjdGl2ZSB7XG5cbiAgICBASW5wdXQoJ2FuY2hvcicpIGFuY2hvcjogc3RyaW5nO1xuICAgIEBJbnB1dCgnb2Zmc2V0Jykgb2Zmc2V0ID0gNTA7XG5cbiAgICBASG9zdExpc3RlbmVyKCdjbGljaycpXG4gICAgb25DbGljaygpIHtcbiAgICAgICAgY29uc3QgZWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKHRoaXMuYW5jaG9yKTtcbiAgICAgICAgd2luZG93LnNjcm9sbEJ5KDAsIGVsZW1lbnQuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkudG9wIC0gdGhpcy5vZmZzZXQpO1xuICAgIH1cblxufVxuIl19