ng-miam 3.7.2 → 3.9.0

package/esm2015/lib/_web-components/recipe-details/recipe-details.module.js

@@ -0,0 +1,86 @@
+import { CommonModule } from '@angular/common';
+import { Injector, NgModule } from '@angular/core';
+import { createCustomElement } from '@angular/elements';
+import { FormsModule } from '@angular/forms';
+import { YouTubePlayerModule } from '@angular/youtube-player';
+import { ComponentsModule } from '../../_components/components.module';
+import { UtilsModule } from '../../_utils/utils.module';
+import { LoaderModule } from '../loader/loader.module';
+import { RecipeAddonComponent } from './recipe-addon/recipe-addon.component';
+import { RecipeDetailsInfosComponent } from './recipe-details-infos/recipe-details-infos.component';
+import { RecipeDetailsIngredientsComponent } from './recipe-details-ingredients/recipe-details-ingredients.component';
+import { RecipeDetailsStepsComponent } from './recipe-details-steps/recipe-details-steps.component';
+import { RecipeDetailsComponent } from './recipe-details.component';
+import * as i0 from "@angular/core";
+export class RecipeDetailsModule {
+    // Create custom elements so the WebComponents can be interpreted by the browser regardless of the js framework used
+    constructor(injector) {
+        const webComponents = {
+            'recipe-addon': RecipeAddonComponent,
+            'recipe-details': RecipeDetailsComponent,
+            'recipe-details-ingredients': RecipeDetailsIngredientsComponent,
+            'recipe-details-steps': RecipeDetailsStepsComponent,
+            'recipe-details-infos': RecipeDetailsInfosComponent
+        };
+        Object.keys(webComponents).map(compName => {
+            const name = `webc-miam-${compName}`;
+            // Avoid duplicate error
+            if (!customElements.get(name)) {
+                const comp = webComponents[compName];
+                const ngElement = createCustomElement(comp, { injector });
+                customElements.define(name, ngElement);
+            }
+        });
+    }
+}
+RecipeDetailsModule.ɵmod = i0.ɵɵdefineNgModule({ type: RecipeDetailsModule });
+RecipeDetailsModule.ɵinj = i0.ɵɵdefineInjector({ factory: function RecipeDetailsModule_Factory(t) { return new (t || RecipeDetailsModule)(i0.ɵɵinject(i0.Injector)); }, imports: [[
+            CommonModule,
+            FormsModule,
+            UtilsModule,
+            ComponentsModule,
+            LoaderModule,
+            YouTubePlayerModule
+        ]] });
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(RecipeDetailsModule, { declarations: [RecipeDetailsIngredientsComponent,
+        RecipeDetailsComponent,
+        RecipeAddonComponent,
+        RecipeDetailsStepsComponent,
+        RecipeDetailsInfosComponent], imports: [CommonModule,
+        FormsModule,
+        UtilsModule,
+        ComponentsModule,
+        LoaderModule,
+        YouTubePlayerModule], exports: [RecipeDetailsIngredientsComponent,
+        RecipeDetailsComponent,
+        RecipeAddonComponent,
+        RecipeDetailsStepsComponent,
+        RecipeDetailsInfosComponent] }); })();
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(RecipeDetailsModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    UtilsModule,
+                    ComponentsModule,
+                    LoaderModule,
+                    YouTubePlayerModule
+                ],
+                declarations: [
+                    RecipeDetailsIngredientsComponent,
+                    RecipeDetailsComponent,
+                    RecipeAddonComponent,
+                    RecipeDetailsStepsComponent,
+                    RecipeDetailsInfosComponent
+                ],
+                exports: [
+                    RecipeDetailsIngredientsComponent,
+                    RecipeDetailsComponent,
+                    RecipeAddonComponent,
+                    RecipeDetailsStepsComponent,
+                    RecipeDetailsInfosComponent
+                ]
+            }]
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjaXBlLWRldGFpbHMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6Ii9idWlsZHMvbWlhbS9uZy1taWFtLXNkay9wcm9qZWN0cy9uZy1taWFtL3NyYy8iLCJzb3VyY2VzIjpbImxpYi9fd2ViLWNvbXBvbmVudHMvcmVjaXBlLWRldGFpbHMvcmVjaXBlLWRldGFpbHMubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDN0MsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDOUQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDdkUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUM3RSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx1REFBdUQsQ0FBQztBQUNwRyxPQUFPLEVBQUUsaUNBQWlDLEVBQUUsTUFBTSxtRUFBbUUsQ0FBQztBQUN0SCxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx1REFBdUQsQ0FBQztBQUNwRyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQzs7QUEwQnBFLE1BQU0sT0FBTyxtQkFBbUI7SUFDOUIsb0hBQW9IO0lBQ3BILFlBQ0UsUUFBa0I7UUFFbEIsTUFBTSxhQUFhLEdBQUc7WUFDcEIsY0FBYyxFQUFFLG9CQUFvQjtZQUNwQyxnQkFBZ0IsRUFBRSxzQkFBc0I7WUFDeEMsNEJBQTRCLEVBQUUsaUNBQWlDO1lBQy9ELHNCQUFzQixFQUFFLDJCQUEyQjtZQUNuRCxzQkFBc0IsRUFBRSwyQkFBMkI7U0FDcEQsQ0FBQztRQUNGLE1BQU0sQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxFQUFFO1lBQ3hDLE1BQU0sSUFBSSxHQUFHLGFBQWEsUUFBUSxFQUFFLENBQUM7WUFDckMsd0JBQXdCO1lBQ3hCLElBQUksQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFO2dCQUM3QixNQUFNLElBQUksR0FBRyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQ3JDLE1BQU0sU0FBUyxHQUFHLG1CQUFtQixDQUFDLElBQUksRUFBRSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7Z0JBQzFELGNBQWMsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDO2FBQ3hDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDOzt1REFyQlUsbUJBQW1CO3FIQUFuQixtQkFBbUIsMENBdkJyQjtZQUNQLFlBQVk7WUFDWixXQUFXO1lBQ1gsV0FBVztZQUNYLGdCQUFnQjtZQUNoQixZQUFZO1lBQ1osbUJBQW1CO1NBQ3BCO3dGQWdCVSxtQkFBbUIsbUJBZDVCLGlDQUFpQztRQUNqQyxzQkFBc0I7UUFDdEIsb0JBQW9CO1FBQ3BCLDJCQUEyQjtRQUMzQiwyQkFBMkIsYUFaM0IsWUFBWTtRQUNaLFdBQVc7UUFDWCxXQUFXO1FBQ1gsZ0JBQWdCO1FBQ2hCLFlBQVk7UUFDWixtQkFBbUIsYUFVbkIsaUNBQWlDO1FBQ2pDLHNCQUFzQjtRQUN0QixvQkFBb0I7UUFDcEIsMkJBQTJCO1FBQzNCLDJCQUEyQjtrREFHbEIsbUJBQW1CO2NBeEIvQixRQUFRO2VBQUM7Z0JBQ1IsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osV0FBVztvQkFDWCxXQUFXO29CQUNYLGdCQUFnQjtvQkFDaEIsWUFBWTtvQkFDWixtQkFBbUI7aUJBQ3BCO2dCQUNELFlBQVksRUFBRTtvQkFDWixpQ0FBaUM7b0JBQ2pDLHNCQUFzQjtvQkFDdEIsb0JBQW9CO29CQUNwQiwyQkFBMkI7b0JBQzNCLDJCQUEyQjtpQkFDNUI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLGlDQUFpQztvQkFDakMsc0JBQXNCO29CQUN0QixvQkFBb0I7b0JBQ3BCLDJCQUEyQjtvQkFDM0IsMkJBQTJCO2lCQUM1QjthQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEluamVjdG9yLCBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgY3JlYXRlQ3VzdG9tRWxlbWVudCB9IGZyb20gJ0Bhbmd1bGFyL2VsZW1lbnRzJztcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgWW91VHViZVBsYXllck1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL3lvdXR1YmUtcGxheWVyJztcbmltcG9ydCB7IENvbXBvbmVudHNNb2R1bGUgfSBmcm9tICcuLi8uLi9fY29tcG9uZW50cy9jb21wb25lbnRzLm1vZHVsZSc7XG5pbXBvcnQgeyBVdGlsc01vZHVsZSB9IGZyb20gJy4uLy4uL191dGlscy91dGlscy5tb2R1bGUnO1xuaW1wb3J0IHsgTG9hZGVyTW9kdWxlIH0gZnJvbSAnLi4vbG9hZGVyL2xvYWRlci5tb2R1bGUnO1xuaW1wb3J0IHsgUmVjaXBlQWRkb25Db21wb25lbnQgfSBmcm9tICcuL3JlY2lwZS1hZGRvbi9yZWNpcGUtYWRkb24uY29tcG9uZW50JztcbmltcG9ydCB7IFJlY2lwZURldGFpbHNJbmZvc0NvbXBvbmVudCB9IGZyb20gJy4vcmVjaXBlLWRldGFpbHMtaW5mb3MvcmVjaXBlLWRldGFpbHMtaW5mb3MuY29tcG9uZW50JztcbmltcG9ydCB7IFJlY2lwZURldGFpbHNJbmdyZWRpZW50c0NvbXBvbmVudCB9IGZyb20gJy4vcmVjaXBlLWRldGFpbHMtaW5ncmVkaWVudHMvcmVjaXBlLWRldGFpbHMtaW5ncmVkaWVudHMuY29tcG9uZW50JztcbmltcG9ydCB7IFJlY2lwZURldGFpbHNTdGVwc0NvbXBvbmVudCB9IGZyb20gJy4vcmVjaXBlLWRldGFpbHMtc3RlcHMvcmVjaXBlLWRldGFpbHMtc3RlcHMuY29tcG9uZW50JztcbmltcG9ydCB7IFJlY2lwZURldGFpbHNDb21wb25lbnQgfSBmcm9tICcuL3JlY2lwZS1kZXRhaWxzLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgRm9ybXNNb2R1bGUsXG4gICAgVXRpbHNNb2R1bGUsXG4gICAgQ29tcG9uZW50c01vZHVsZSxcbiAgICBMb2FkZXJNb2R1bGUsXG4gICAgWW91VHViZVBsYXllck1vZHVsZVxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBSZWNpcGVEZXRhaWxzSW5ncmVkaWVudHNDb21wb25lbnQsXG4gICAgUmVjaXBlRGV0YWlsc0NvbXBvbmVudCxcbiAgICBSZWNpcGVBZGRvbkNvbXBvbmVudCxcbiAgICBSZWNpcGVEZXRhaWxzU3RlcHNDb21wb25lbnQsXG4gICAgUmVjaXBlRGV0YWlsc0luZm9zQ29tcG9uZW50XG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBSZWNpcGVEZXRhaWxzSW5ncmVkaWVudHNDb21wb25lbnQsXG4gICAgUmVjaXBlRGV0YWlsc0NvbXBvbmVudCxcbiAgICBSZWNpcGVBZGRvbkNvbXBvbmVudCxcbiAgICBSZWNpcGVEZXRhaWxzU3RlcHNDb21wb25lbnQsXG4gICAgUmVjaXBlRGV0YWlsc0luZm9zQ29tcG9uZW50XG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgUmVjaXBlRGV0YWlsc01vZHVsZSB7XG4gIC8vIENyZWF0ZSBjdXN0b20gZWxlbWVudHMgc28gdGhlIFdlYkNvbXBvbmVudHMgY2FuIGJlIGludGVycHJldGVkIGJ5IHRoZSBicm93c2VyIHJlZ2FyZGxlc3Mgb2YgdGhlIGpzIGZyYW1ld29yayB1c2VkXG4gIGNvbnN0cnVjdG9yKFxuICAgIGluamVjdG9yOiBJbmplY3RvcixcbiAgKSB7XG4gICAgY29uc3Qgd2ViQ29tcG9uZW50cyA9IHtcbiAgICAgICdyZWNpcGUtYWRkb24nOiBSZWNpcGVBZGRvbkNvbXBvbmVudCxcbiAgICAgICdyZWNpcGUtZGV0YWlscyc6IFJlY2lwZURldGFpbHNDb21wb25lbnQsXG4gICAgICAncmVjaXBlLWRldGFpbHMtaW5ncmVkaWVudHMnOiBSZWNpcGVEZXRhaWxzSW5ncmVkaWVudHNDb21wb25lbnQsXG4gICAgICAncmVjaXBlLWRldGFpbHMtc3RlcHMnOiBSZWNpcGVEZXRhaWxzU3RlcHNDb21wb25lbnQsXG4gICAgICAncmVjaXBlLWRldGFpbHMtaW5mb3MnOiBSZWNpcGVEZXRhaWxzSW5mb3NDb21wb25lbnRcbiAgICB9O1xuICAgIE9iamVjdC5rZXlzKHdlYkNvbXBvbmVudHMpLm1hcChjb21wTmFtZSA9PiB7XG4gICAgICBjb25zdCBuYW1lID0gYHdlYmMtbWlhbS0ke2NvbXBOYW1lfWA7XG4gICAgICAvLyBBdm9pZCBkdXBsaWNhdGUgZXJyb3JcbiAgICAgIGlmICghY3VzdG9tRWxlbWVudHMuZ2V0KG5hbWUpKSB7XG4gICAgICAgIGNvbnN0IGNvbXAgPSB3ZWJDb21wb25lbnRzW2NvbXBOYW1lXTtcbiAgICAgICAgY29uc3QgbmdFbGVtZW50ID0gY3JlYXRlQ3VzdG9tRWxlbWVudChjb21wLCB7IGluamVjdG9yIH0pO1xuICAgICAgICBjdXN0b21FbGVtZW50cy5kZWZpbmUobmFtZSwgbmdFbGVtZW50KTtcbiAgICAgIH1cbiAgICB9KTtcbiAgfVxufVxuIl19

package/esm2015/lib/_web-components/recipe-form/recipe-form.component.js

@@ -148,7 +148,7 @@ export class RecipeFormComponent {
         this.customSubmitCallback = false; // If true, emit recipeChange to let the parent handle recipe saving
         this.icon = Icon;
         this.dificulties = ['facile', 'moyen', 'difficile'];
-        this.iconsDificulties = [this.icon.DifficultyLow, this.icon.DifficultyMedium, this.icon.DifficultyHight];
+        this.iconsDificulties = [this.icon.DifficultyLow, this.icon.DifficultyMedium, this.icon.DifficultyHigh];
         this.costs = ['faible', 'moyen', 'élevé'];
         this.iconsCosts = [this.icon.CostLow, this.icon.CostMedium, this.icon.CostHight];
         this.isSubmiting = false;
@@ -473,4 +473,4 @@ RecipeFormComponent.ɵcmp = i0.ɵɵdefineComponent({ type: RecipeFormComponent,
         }], canceled: [{
             type: Output
         }] }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipe-form.component.js","sourceRoot":"/builds/miam/ng-miam-sdk/projects/ng-miam/src/","sources":["lib/_web-components/recipe-form/recipe-form.component.ts","lib/_web-components/recipe-form/recipe-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ViewEncapsulation,\n  ChangeDetectionStrategy,\n  OnChanges,\n  SimpleChanges,\n  Input,\n  Output,\n  EventEmitter,\n  ChangeDetectorRef,\n  OnDestroy,\n} from '@angular/core';\nimport { FormArray, FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms';\nimport { Recipe } from '../../_models/recipe';\nimport { Icon } from '../../_types/icon.enum';\nimport { OnInit } from '@angular/core';\nimport { forkJoin, Observable, of, Subscription } from 'rxjs';\nimport { Ingredient } from '../../_models/ingredient';\nimport { RecipeStep } from '../../_models/recipe-step';\nimport {\n  IngredientsService,\n  RecipesService,\n  RecipeStatusService,\n  RecipeStepsService,\n  RecipeTypeService,\n  UserService\n} from '../../_services';\nimport { map, skipWhile, switchMap, take, tap } from 'rxjs/operators';\nimport { DocumentResource } from 'ngx-jsonapi';\nimport { RecipeProviderService } from '../../_services';\nimport { RecipeStatus } from '../../_models';\nimport { MediaMatcher } from '@angular/cdk/layout';\n\n\n@Component({\n  selector: 'ng-miam-recipe-form',\n  templateUrl: './recipe-form.component.html',\n  styleUrls: ['./recipe-form.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class RecipeFormComponent implements OnChanges, OnInit, OnDestroy {\n\n  @Input() recipe: Recipe;\n  @Input() secondaryActionText = 'Annuler';\n  @Input() primaryActionText = 'Enregistrer la recette';\n  @Input() secondaryButtonDisable = false; // If true, disable the secondaryButton while there are no changes in the form\n  @Input() customSubmitCallback = false; // If true, emit recipeChange to let the parent handle recipe saving\n  @Output() recipeChange: EventEmitter<Recipe>;\n  @Output() canceled: EventEmitter<Recipe>; // TODO: For more clarity, split into 'canceled<void>' et 'secondaryAction<Recipe>'\n\n  public recipeForm: FormGroup;\n  public isUpdate: boolean;\n  public icon = Icon;\n  public dificulties = ['facile', 'moyen', 'difficile'];\n  public iconsDificulties = [this.icon.DifficultyLow, this.icon.DifficultyMedium, this.icon.DifficultyHight];\n  public costs = ['faible', 'moyen', 'élevé'];\n  public iconsCosts = [this.icon.CostLow, this.icon.CostMedium, this.icon.CostHight];\n  public deleteIngredientsList: string[];\n  public deleteStepsList: string[];\n  public isAdmin: boolean;\n  public statuses: Observable<RecipeStatus[]>;\n  public isSubmiting = false;\n\n  private formSubscription: Subscription;\n  private subscriptions: Subscription[];\n\n  constructor(\n    private fb: FormBuilder,\n    private userService: UserService,\n    public cdr: ChangeDetectorRef,\n    public recipeProviderservice: RecipeProviderService,\n    private recipeService: RecipesService,\n    public recipeTypeService: RecipeTypeService,\n    private ingredientService: IngredientsService,\n    private recipeStepsService: RecipeStepsService,\n    public mediaMatcher: MediaMatcher,\n    public statusService: RecipeStatusService\n  ) {\n\n    this.canceled = new EventEmitter();\n    this.recipeChange = new EventEmitter();\n    this.deleteIngredientsList = [];\n    this.deleteStepsList = [];\n    this.subscriptions = [];\n    this.statuses = this.statusService.all().pipe(map(res => res.data));\n  }\n\n  ngOnInit(): void {\n    this.subscriptions.push(\n      this.userService.isAdmin.subscribe(isAdmin => {\n        this.isAdmin = isAdmin;\n        this.cdr.detectChanges();\n      }));\n    this.InitRecipe().pipe(take(1)).subscribe();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.hasOwnProperty('recipe') && this.recipe != null) {\n      this.isUpdate = true;\n      this.initForm(this.recipe);\n    }\n    this.cdr.detectChanges();\n  }\n\n  ngOnDestroy(): void {\n    this.formSubscription.unsubscribe();\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n\n\n  /**\n   * Only for recipe creation.\n   * Init blank recipe\n   */\n  private InitRecipe(): Observable<any> {\n    // first state after creation 'll be SUBMITTED we preset this field because\n    // normal user can't fill it and it's a mandatory field\n    // admin can still override it\n    if (this.recipe) { return of(null); }\n    return this.statusService.submitted.pipe(switchMap(status =>\n      this.userService.userProvider.pipe(skipWhile(provider => provider == null),\n      tap(recipeProvider => {\n        this.recipe = this.recipeService.new();\n        this.recipe.addRelationship(status, 'recipe-status');\n        this.recipe.addRelationship(recipeProvider, 'recipe-provider');\n        delete this.recipe.id;\n        this.initForm(this.recipe);\n        this.cdr.detectChanges();\n      }))));\n  }\n\n  /**\n   * Save changes and return them in case they could be used after but don't save it\n   * TODO: When we split the output, rename secondaryAction() -> secondaryAction.emit(this.recipe)\n   */\n  public cancel() {\n    this.setRelationShipIfFormPartIsDirty('recipe-type');\n    this.setRelationShipIfFormPartIsDirty('recipe-status');\n    this.setRelationShipIfFormPartIsDirty('recipe-provider');\n    this.recipe.attributes = { ... this.recipe.attributes, ...this.recipeForm.getRawValue().attributes };\n    this.canceled.emit(this.recipe);\n  }\n\n  public addToDeleteIngredientsList(ingredientId: string): void {\n    this.deleteIngredientsList.push(ingredientId);\n  }\n\n  public addToDeleteStepsList(stepId: string): void {\n    this.deleteStepsList.push(stepId);\n  }\n\n  public submit(): void {\n    this.isSubmiting = true;\n    this.upsertRecipe().subscribe((recipe) => {\n      if (recipe) {\n        this.deleteStepsList = [];\n        this.deleteIngredientsList = [];\n        this.isSubmiting = false;\n        this.handleEmition(recipe);\n      }\n    });\n  }\n\n  /**\n   * Classic use case: if the form is invalid, if it is not dirty or if the recipe is being submitted, the buttons must be disabled\n   * If recipe == null -> classic use case\n   * If recipe != null & status != DRAFT -> classic use case\n   * if recipe != null & statu == DRAFT -> the buttons must never be disabled\n   * @returns true if the buttons should be disabled\n   */\n  public cantSubmit() {\n    return (!this.recipe || this.recipe.status.name !== this.statusService.draftValue.name) &&\n      (this.recipeForm?.invalid || !this.recipeForm?.dirty || this.isSubmiting);\n  }\n\n  /**\n   * this function fill form values with given recipe\n   * Form is divide in 4 part attributes,type, ingredients, steps\n   * to folow recipe model in on hand and in other hand to update only\n   * parts that have been change by user thanks to dirty attribute on\n   * each of those parts\n   * @param recipe use to fill form\n   */\n  private initForm(recipe: Recipe): void {\n    if (this.formSubscription) {\n      this.formSubscription.unsubscribe();\n    }\n    this.recipeForm = this.fb.group({\n      'recipe-status': new FormControl(recipe?.relationships?.[`recipe-status`]?.data, Validators.required),\n      'recipe-provider': new FormControl(recipe?.relationships?.[`recipe-provider`]?.data?.id ?\n        recipe?.relationships?.[`recipe-provider`]?.data : 'personal', Validators.required),\n      attributes: this.fb.group({\n        title: new FormControl(recipe.attributes[`title`], Validators.required),\n        'media-url': new FormControl(recipe.attributes[`media-url`]),\n        ['number-of-guests']: new FormControl(recipe.guests ?\n          recipe.guests : 4, [Validators.min(1), Validators.max(999)]),\n        'description': new FormControl(recipe.attributes[`description`]),\n        'preparation-time': new FormControl(recipe.attributes[`preparation-time`] ? recipe.attributes[`preparation-time`] : ''),\n        'preheating-time': new FormControl(recipe.attributes[`preheating-time`]),\n        'cooking-time': new FormControl(recipe.attributes[`cooking-time`]),\n        'resting-time': new FormControl(recipe.attributes[`resting-time`]),\n        difficulty: new FormControl(recipe.attributes[`difficulty`] ? recipe.attributes[`difficulty`] : 1, Validators.required),\n      }),\n      'recipe-type': new FormControl(recipe.relationships[`recipe-type`].data.id ? recipe.relationships[`recipe-type`].data : null,\n        Validators.required),\n      ingredients: this.initIngredientFormArray(recipe),\n      steps: this.initStepFormArray(recipe)\n    });\n    this.formSubscription = this.recipeForm.valueChanges.subscribe(() => {\n      this.cdr.detectChanges();\n    });\n  }\n\n  /**\n   * For each Recipe Ingredient will create a form\n   * that will be group in an form Array\n   * @param recipe current recipe that 'll fill form\n   */\n  private initIngredientFormArray(recipe: Recipe): FormArray {\n    const ingredients = this.fb.array([]);\n    const recipeIngredients = recipe.relationships[`ingredients`].data;\n    recipeIngredients.forEach((ingredient: Ingredient) => {\n      ingredients.push(this.fb.group({\n        id: new FormControl(ingredient.id),\n        attributes: this.fb.group({\n          quantity: new FormControl(ingredient.attributes.quantity, Validators.required),\n          unit: new FormControl(ingredient.attributes.unit, Validators.required),\n          name: new FormControl(ingredient.attributes.name, Validators.required),\n          'picture-url': new FormControl(ingredient.attributes['picture-url'])\n        })\n      }));\n    });\n    return ingredients;\n  }\n\n  /**\n   * For each Recipe steps will create a form\n   * that will be group in an form Array\n   * @param recipe current recipe that 'll fill form\n   */\n  private initStepFormArray(recipe: Recipe): FormArray {\n    const steps = this.fb.array([]);\n    recipe.steps.forEach((step: RecipeStep) => steps.push(this.fb.group({\n      id: new FormControl(step.id),\n      attributes: this.fb.group({\n        'step-number': new FormControl(step.attributes['step-number']),\n        description: new FormControl(step.attributes.description)\n      })\n    })));\n    return steps;\n  }\n\n  /**\n   * Merge current recipe with form result\n   * return an obsevable that'll update or create recipe\n   */\n  private updateRecipeAttributes(): Observable<Recipe> {\n    const param = {\n      include: ['ingredients', 'recipe-steps', 'recipe-status', 'recipe-provider', 'recipe-type', 'tags']\n    };\n    this.recipe.attributes = { ... this.recipe.attributes, ...this.recipeForm.getRawValue().attributes };\n    return this.recipe.save(param).pipe(map((res: DocumentResource<Recipe>) => {\n      // we are in a creation, the save is a post that return result\n      if (res && res.data) {\n        const recipe = this.recipeService.new();\n        recipe.fill(res);\n        return recipe[`data`] as Recipe;\n      } else { // we are in a patch return the current recipe already updated\n        return this.recipe;\n      }\n    }));\n  }\n\n  /**\n   * Update recipe's relationships Ingredient and  Steps\n   * if at least one steps has changed will update the full list of step,\n   * if at least one ingredient changed it 'll update the full list of ingredient,\n   * it can update ingrdient list without updating steps list and vice versa.\n   * @param currentRecipe to update this recipe already exist in backend it has to had an id\n   */\n  public updateRecipeRelationShips(currentRecipe: Recipe): Observable<Recipe> {\n    const formValue = this.recipeForm.getRawValue();\n    let obsList = [];\n    if (this.recipeForm.get('ingredients').dirty){\n      const ingredients = this.ingredientService.createOrUpdateIngredients(currentRecipe, formValue.ingredients);\n      obsList.push(this.ingredientService.upsertIngredientList(ingredients));\n    }\n    if (this.deleteIngredientsList.length > 0){\n      obsList.push(this.ingredientService.deleteIngredientList(this.deleteIngredientsList));\n    }\n    if (this.recipeForm.get('steps').dirty){\n      const steps = this.recipeStepsService.formToStepsMapper(currentRecipe, formValue.steps);\n      obsList.push(this.recipeStepsService.createOrUpdateRelatedSteps(steps));\n    }\n    if (this.deleteStepsList.length > 0){\n      obsList.push(this.recipeStepsService.deleteStepList(this.deleteStepsList));\n    }\n    return forkJoin(obsList).pipe(\n      map(() => currentRecipe)\n    );\n  }\n\n  public relationshipsChanged(): boolean {\n    const ingChange = this.recipeForm.get('ingredients').dirty || this.deleteIngredientsList.length > 0;\n    const stepChange = this.recipeForm.get('steps').dirty || this.deleteStepsList.length > 0;\n    return ingChange || stepChange;\n  }\n\n  /**\n   * Update or create Recipe\n   * it can only update changed part of a recipe\n   */\n  private upsertRecipe(): Observable<Recipe> {\n    // break upsert : we have to choose beetwen relationships and this field\n    delete this.recipe.attributes[`ingredients-str`];\n    delete this.recipe.attributes[`suggested`];\n    delete this.recipe.attributes[`popularity`];\n    this.handleRecipeStatusWorkflow();\n    this.setRelationShipIfFormPartIsDirty('recipe-type');\n    this.setRelationShipIfFormPartIsDirty('recipe-status');\n    this.setRelationShipIfFormPartIsDirty('recipe-provider');\n    if (this.customSubmitCallback) {\n      this.recipe.attributes = { ... this.recipe.attributes, ...this.recipeForm.getRawValue().attributes };\n      this.recipeChange.emit(this.recipe);\n      this.recipeForm.get('attributes').markAsDirty();\n      this.isSubmiting = false;\n      return of(null);\n    }\n    if (this.recipeForm.get('attributes')?.dirty) {\n      return this.updateRecipeAttributes().pipe(\n        switchMap(recipe => {\n          // may be a creation or an update, anyway updateRecipeAttributes return the final recipe\n          // we update the current recipe, usefull in case of creation as it is undefined until now\n          if (recipe) {\n            this.recipe = recipe;\n          }\n          if (this.relationshipsChanged()) {\n            return this.updateRecipeRelationShips(this.recipe);\n          } else {\n            return of(recipe);\n          }\n        })\n      );\n    } else {\n      // can only be an update, with only relationships modifs\n      return this.updateRecipeRelationShips(this.recipe);\n    }\n  }\n\n  private setRelationShipIfFormPartIsDirty(formPart: string): void {\n    if (this.recipeForm.get(`${formPart}`)?.dirty) {\n      // force full recipe update\n      this.recipeForm.get('attributes').markAsDirty();\n      this.recipe.addRelationship(this.recipeForm.get(`${formPart}`).value, `${formPart}`);\n    }\n  }\n\n  /**\n   * Emit when change has been done back\n   * reset form's states\n   */\n  private handleEmition(recipe: Recipe): void {\n    this.recipeChange.emit(recipe ? recipe : this.recipe);\n    this.recipeForm.markAsPristine();\n  }\n\n  private handleRecipeStatusWorkflow() {\n    // use if we are patching recipe as an non Admin user\n    if (!this.isAdmin && !this.customSubmitCallback) {\n      this.recipeForm.get('recipe-status').patchValue(this.statusService.submittedValue);\n      this.recipeForm.get('recipe-status').markAsDirty();\n    }\n    let formMedia = this.recipeForm.get('attributes').get('media-url');\n    if (!this.recipe.attributes['media-url'] && !formMedia.value) {\n      formMedia.patchValue('https://storage.googleapis.com/assets.miam.tech/generic/personal-recipes/default_img_personal_recipe.jpg')\n    }\n  }\n}\n\n\n","<form *ngIf='recipeForm' [formGroup]=\"recipeForm\" class=\"form-container\">\n  <ng-container [formGroup]=\"recipeForm?.get('attributes')\">\n    <ng-miam-text-input class=\"m-title-text-input\" ngDefaultControl [formControl]=\"recipeForm?.get('attributes')?.get('title')\" placeholder=\"Titre de la recette\"></ng-miam-text-input>\n    <div class=\"row-container\">\n      <div class=\"input-container\">\n        <ng-miam-drag-drop-input ngDefaultControl buttonText='Ajouter une photo'  [formControl]=\"recipeForm?.get('attributes')?.get('media-url')\"\n          [imageUrl]=\"recipeForm?.get('attributes')?.get('media-url')?.value\" [photoMode]='true'>\n        </ng-miam-drag-drop-input>\n        <div class=\"recipe-form__guests m-default-card\">\n          <span class=\"recipe-form__guests__label\">Nombre de convives</span>\n          <ng-miam-counter-input ngDefaultControl formControlName=\"number-of-guests\"\n            [formControl]=\"this.recipeForm.controls['attributes']['controls'][['number-of-guests']]\"\n            counter='4' minRange='0' maxRange='999'>\n          </ng-miam-counter-input>\n        </div>\n      </div>\n      <div class=\"recipe-form__attibutes\">\n        <ng-miam-select-input ngDefaultControl placeholder='Choisir un type' labelPath='attributes.name'\n          [options]=\"recipeTypeService?.getTypes() | async\" [formControl]=\"recipeForm?.get('recipe-type')\">\n        </ng-miam-select-input>\n        <div class=\"recipe-form__attibutes__sliders\">\n          <div class=\"recipe-form__attibutes__slider\">\n            <ng-miam-slider ngDefaultControl [steps]=\"dificulties\"\n              [formControl]=\"recipeForm?.get('attributes')?.get('difficulty')\" [icons]=\"iconsDificulties\">\n            </ng-miam-slider>\n          </div>\n        </div>\n        <div *ngIf='recipeForm' class=\"recipe-form__attibutes__times\">\n          <ng-miam-time-picker ngDefaultControl title='Temps de préparation'\n            [formControl]=\"recipeForm?.get('attributes')?.get('preparation-time')\" [icon]='icon.Time'>\n          </ng-miam-time-picker>\n          <ng-miam-time-picker ngDefaultControl title='Temps de cuisson'\n            [formControl]=\"recipeForm?.get('attributes')?.get('cooking-time')\" [icon]='icon.Hot'></ng-miam-time-picker>\n          <ng-miam-time-picker ngDefaultControl title='Temps de repos'\n            [formControl]=\"recipeForm?.get('attributes')?.get('resting-time')\" [icon]='icon.Wait'></ng-miam-time-picker>\n          <ng-miam-time-picker ngDefaultControl title='Temps de préchauffage'\n            [formControl]=\"recipeForm?.get('attributes')?.get('resting-time')\" [icon]='icon.Preheat'>\n          </ng-miam-time-picker>\n        </div>\n      </div>\n    </div>\n  </ng-container>\n  <div class=\"row-container\">\n    <div class=\"input-container\">\n      <ng-miam-list-input  label=\"Ingrédients\" ngDefaultControl (deleteId)=\"addToDeleteIngredientsList($event)\" [ingredientMode]='true'\n        [list]=\"recipeForm.get('ingredients')\" formArrayName=\"ingredients\" hint='ingrédients'>\n      </ng-miam-list-input>\n    </div>\n    <div class=\"input-container\">\n      <ng-miam-list-input ngDefaultControl label=\"Étapes\" formArrayName=\"steps\" (deleteId)=\"addToDeleteStepsList($event)\"\n        [list]=\"recipeForm.get('steps')\" hint='étapes'></ng-miam-list-input>\n    </div>\n    <div class=\"input-container\" *ngIf=\"isAdmin\">\n\n      <ng-miam-select-input ngDefaultControl placeholder='Choisir un status' labelPath='attributes.name'\n      [options]=\"statuses | async\" [formControl]=\"recipeForm?.get('recipe-status')\">\n      </ng-miam-select-input>\n\n      <ng-miam-select-input ngDefaultControl placeholder='Choisir un provider' labelPath='attributes.name'\n      [options]=\"recipeProviderservice?.providerList | async\"[formControl]=\"recipeForm?.get('recipe-provider')\">\n      </ng-miam-select-input>\n      <textarea cdkTextareaAutosize cdkAutosizeMinRows=\"20\" cdkAutosizeMaxRows=\"50\" class=\"m-input\"\n        [formControl]=\"recipeForm?.get('attributes')?.get('description')\"></textarea>\n    </div>\n  </div>\n\n</form>\n<div class='button-row'>\n  <button class=\"m-button-secondary\" (click)='cancel()'>Annuler</button>\n  <button class=\"m-button-primary\" (click)='submit()' [disabled]='recipeForm?.invalid || !recipeForm?.dirty || isSubmiting'>\n    Enregistrer la recette\n    </button>\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipe-form.component.js","sourceRoot":"/builds/miam/ng-miam-sdk/projects/ng-miam/src/","sources":["lib/_web-components/recipe-form/recipe-form.component.ts","lib/_web-components/recipe-form/recipe-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ViewEncapsulation,\n  ChangeDetectionStrategy,\n  OnChanges,\n  SimpleChanges,\n  Input,\n  Output,\n  EventEmitter,\n  ChangeDetectorRef,\n  OnDestroy,\n} from '@angular/core';\nimport { FormArray, FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms';\nimport { Recipe } from '../../_models/recipe';\nimport { Icon } from '../../_types/icon.enum';\nimport { OnInit } from '@angular/core';\nimport { forkJoin, Observable, of, Subscription } from 'rxjs';\nimport { Ingredient } from '../../_models/ingredient';\nimport { RecipeStep } from '../../_models/recipe-step';\nimport {\n  IngredientsService,\n  RecipesService,\n  RecipeStatusService,\n  RecipeStepsService,\n  RecipeTypeService,\n  UserService\n} from '../../_services';\nimport { map, skipWhile, switchMap, take, tap } from 'rxjs/operators';\nimport { DocumentResource } from 'ngx-jsonapi';\nimport { RecipeProviderService } from '../../_services';\nimport { RecipeStatus } from '../../_models';\nimport { MediaMatcher } from '@angular/cdk/layout';\n\n\n@Component({\n  selector: 'ng-miam-recipe-form',\n  templateUrl: './recipe-form.component.html',\n  styleUrls: ['./recipe-form.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class RecipeFormComponent implements OnChanges, OnInit, OnDestroy {\n\n  @Input() recipe: Recipe;\n  @Input() secondaryActionText = 'Annuler';\n  @Input() primaryActionText = 'Enregistrer la recette';\n  @Input() secondaryButtonDisable = false; // If true, disable the secondaryButton while there are no changes in the form\n  @Input() customSubmitCallback = false; // If true, emit recipeChange to let the parent handle recipe saving\n  @Output() recipeChange: EventEmitter<Recipe>;\n  @Output() canceled: EventEmitter<Recipe>; // TODO: For more clarity, split into 'canceled<void>' et 'secondaryAction<Recipe>'\n\n  public recipeForm: FormGroup;\n  public isUpdate: boolean;\n  public icon = Icon;\n  public dificulties = ['facile', 'moyen', 'difficile'];\n  public iconsDificulties = [this.icon.DifficultyLow, this.icon.DifficultyMedium, this.icon.DifficultyHigh];\n  public costs = ['faible', 'moyen', 'élevé'];\n  public iconsCosts = [this.icon.CostLow, this.icon.CostMedium, this.icon.CostHight];\n  public deleteIngredientsList: string[];\n  public deleteStepsList: string[];\n  public isAdmin: boolean;\n  public statuses: Observable<RecipeStatus[]>;\n  public isSubmiting = false;\n\n  private formSubscription: Subscription;\n  private subscriptions: Subscription[];\n\n  constructor(\n    private fb: FormBuilder,\n    private userService: UserService,\n    public cdr: ChangeDetectorRef,\n    public recipeProviderservice: RecipeProviderService,\n    private recipeService: RecipesService,\n    public recipeTypeService: RecipeTypeService,\n    private ingredientService: IngredientsService,\n    private recipeStepsService: RecipeStepsService,\n    public mediaMatcher: MediaMatcher,\n    public statusService: RecipeStatusService\n  ) {\n\n    this.canceled = new EventEmitter();\n    this.recipeChange = new EventEmitter();\n    this.deleteIngredientsList = [];\n    this.deleteStepsList = [];\n    this.subscriptions = [];\n    this.statuses = this.statusService.all().pipe(map(res => res.data));\n  }\n\n  ngOnInit(): void {\n    this.subscriptions.push(\n      this.userService.isAdmin.subscribe(isAdmin => {\n        this.isAdmin = isAdmin;\n        this.cdr.detectChanges();\n      }));\n    this.InitRecipe().pipe(take(1)).subscribe();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.hasOwnProperty('recipe') && this.recipe != null) {\n      this.isUpdate = true;\n      this.initForm(this.recipe);\n    }\n    this.cdr.detectChanges();\n  }\n\n  ngOnDestroy(): void {\n    this.formSubscription.unsubscribe();\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n\n\n  /**\n   * Only for recipe creation.\n   * Init blank recipe\n   */\n  private InitRecipe(): Observable<any> {\n    // first state after creation 'll be SUBMITTED we preset this field because\n    // normal user can't fill it and it's a mandatory field\n    // admin can still override it\n    if (this.recipe) { return of(null); }\n    return this.statusService.submitted.pipe(switchMap(status =>\n      this.userService.userProvider.pipe(skipWhile(provider => provider == null),\n      tap(recipeProvider => {\n        this.recipe = this.recipeService.new();\n        this.recipe.addRelationship(status, 'recipe-status');\n        this.recipe.addRelationship(recipeProvider, 'recipe-provider');\n        delete this.recipe.id;\n        this.initForm(this.recipe);\n        this.cdr.detectChanges();\n      }))));\n  }\n\n  /**\n   * Save changes and return them in case they could be used after but don't save it\n   * TODO: When we split the output, rename secondaryAction() -> secondaryAction.emit(this.recipe)\n   */\n  public cancel() {\n    this.setRelationShipIfFormPartIsDirty('recipe-type');\n    this.setRelationShipIfFormPartIsDirty('recipe-status');\n    this.setRelationShipIfFormPartIsDirty('recipe-provider');\n    this.recipe.attributes = { ... this.recipe.attributes, ...this.recipeForm.getRawValue().attributes };\n    this.canceled.emit(this.recipe);\n  }\n\n  public addToDeleteIngredientsList(ingredientId: string): void {\n    this.deleteIngredientsList.push(ingredientId);\n  }\n\n  public addToDeleteStepsList(stepId: string): void {\n    this.deleteStepsList.push(stepId);\n  }\n\n  public submit(): void {\n    this.isSubmiting = true;\n    this.upsertRecipe().subscribe((recipe) => {\n      if (recipe) {\n        this.deleteStepsList = [];\n        this.deleteIngredientsList = [];\n        this.isSubmiting = false;\n        this.handleEmition(recipe);\n      }\n    });\n  }\n\n  /**\n   * Classic use case: if the form is invalid, if it is not dirty or if the recipe is being submitted, the buttons must be disabled\n   * If recipe == null -> classic use case\n   * If recipe != null & status != DRAFT -> classic use case\n   * if recipe != null & statu == DRAFT -> the buttons must never be disabled\n   * @returns true if the buttons should be disabled\n   */\n  public cantSubmit() {\n    return (!this.recipe || this.recipe.status.name !== this.statusService.draftValue.name) &&\n      (this.recipeForm?.invalid || !this.recipeForm?.dirty || this.isSubmiting);\n  }\n\n  /**\n   * this function fill form values with given recipe\n   * Form is divide in 4 part attributes,type, ingredients, steps\n   * to folow recipe model in on hand and in other hand to update only\n   * parts that have been change by user thanks to dirty attribute on\n   * each of those parts\n   * @param recipe use to fill form\n   */\n  private initForm(recipe: Recipe): void {\n    if (this.formSubscription) {\n      this.formSubscription.unsubscribe();\n    }\n    this.recipeForm = this.fb.group({\n      'recipe-status': new FormControl(recipe?.relationships?.[`recipe-status`]?.data, Validators.required),\n      'recipe-provider': new FormControl(recipe?.relationships?.[`recipe-provider`]?.data?.id ?\n        recipe?.relationships?.[`recipe-provider`]?.data : 'personal', Validators.required),\n      attributes: this.fb.group({\n        title: new FormControl(recipe.attributes[`title`], Validators.required),\n        'media-url': new FormControl(recipe.attributes[`media-url`]),\n        ['number-of-guests']: new FormControl(recipe.guests ?\n          recipe.guests : 4, [Validators.min(1), Validators.max(999)]),\n        'description': new FormControl(recipe.attributes[`description`]),\n        'preparation-time': new FormControl(recipe.attributes[`preparation-time`] ? recipe.attributes[`preparation-time`] : ''),\n        'preheating-time': new FormControl(recipe.attributes[`preheating-time`]),\n        'cooking-time': new FormControl(recipe.attributes[`cooking-time`]),\n        'resting-time': new FormControl(recipe.attributes[`resting-time`]),\n        difficulty: new FormControl(recipe.attributes[`difficulty`] ? recipe.attributes[`difficulty`] : 1, Validators.required),\n      }),\n      'recipe-type': new FormControl(recipe.relationships[`recipe-type`].data.id ? recipe.relationships[`recipe-type`].data : null,\n        Validators.required),\n      ingredients: this.initIngredientFormArray(recipe),\n      steps: this.initStepFormArray(recipe)\n    });\n    this.formSubscription = this.recipeForm.valueChanges.subscribe(() => {\n      this.cdr.detectChanges();\n    });\n  }\n\n  /**\n   * For each Recipe Ingredient will create a form\n   * that will be group in an form Array\n   * @param recipe current recipe that 'll fill form\n   */\n  private initIngredientFormArray(recipe: Recipe): FormArray {\n    const ingredients = this.fb.array([]);\n    const recipeIngredients = recipe.relationships[`ingredients`].data;\n    recipeIngredients.forEach((ingredient: Ingredient) => {\n      ingredients.push(this.fb.group({\n        id: new FormControl(ingredient.id),\n        attributes: this.fb.group({\n          quantity: new FormControl(ingredient.attributes.quantity, Validators.required),\n          unit: new FormControl(ingredient.attributes.unit, Validators.required),\n          name: new FormControl(ingredient.attributes.name, Validators.required),\n          'picture-url': new FormControl(ingredient.attributes['picture-url'])\n        })\n      }));\n    });\n    return ingredients;\n  }\n\n  /**\n   * For each Recipe steps will create a form\n   * that will be group in an form Array\n   * @param recipe current recipe that 'll fill form\n   */\n  private initStepFormArray(recipe: Recipe): FormArray {\n    const steps = this.fb.array([]);\n    recipe.steps.forEach((step: RecipeStep) => steps.push(this.fb.group({\n      id: new FormControl(step.id),\n      attributes: this.fb.group({\n        'step-number': new FormControl(step.attributes['step-number']),\n        description: new FormControl(step.attributes.description)\n      })\n    })));\n    return steps;\n  }\n\n  /**\n   * Merge current recipe with form result\n   * return an obsevable that'll update or create recipe\n   */\n  private updateRecipeAttributes(): Observable<Recipe> {\n    const param = {\n      include: ['ingredients', 'recipe-steps', 'recipe-status', 'recipe-provider', 'recipe-type', 'tags']\n    };\n    this.recipe.attributes = { ... this.recipe.attributes, ...this.recipeForm.getRawValue().attributes };\n    return this.recipe.save(param).pipe(map((res: DocumentResource<Recipe>) => {\n      // we are in a creation, the save is a post that return result\n      if (res && res.data) {\n        const recipe = this.recipeService.new();\n        recipe.fill(res);\n        return recipe[`data`] as Recipe;\n      } else { // we are in a patch return the current recipe already updated\n        return this.recipe;\n      }\n    }));\n  }\n\n  /**\n   * Update recipe's relationships Ingredient and  Steps\n   * if at least one steps has changed will update the full list of step,\n   * if at least one ingredient changed it 'll update the full list of ingredient,\n   * it can update ingrdient list without updating steps list and vice versa.\n   * @param currentRecipe to update this recipe already exist in backend it has to had an id\n   */\n  public updateRecipeRelationShips(currentRecipe: Recipe): Observable<Recipe> {\n    const formValue = this.recipeForm.getRawValue();\n    let obsList = [];\n    if (this.recipeForm.get('ingredients').dirty){\n      const ingredients = this.ingredientService.createOrUpdateIngredients(currentRecipe, formValue.ingredients);\n      obsList.push(this.ingredientService.upsertIngredientList(ingredients));\n    }\n    if (this.deleteIngredientsList.length > 0){\n      obsList.push(this.ingredientService.deleteIngredientList(this.deleteIngredientsList));\n    }\n    if (this.recipeForm.get('steps').dirty){\n      const steps = this.recipeStepsService.formToStepsMapper(currentRecipe, formValue.steps);\n      obsList.push(this.recipeStepsService.createOrUpdateRelatedSteps(steps));\n    }\n    if (this.deleteStepsList.length > 0){\n      obsList.push(this.recipeStepsService.deleteStepList(this.deleteStepsList));\n    }\n    return forkJoin(obsList).pipe(\n      map(() => currentRecipe)\n    );\n  }\n\n  public relationshipsChanged(): boolean {\n    const ingChange = this.recipeForm.get('ingredients').dirty || this.deleteIngredientsList.length > 0;\n    const stepChange = this.recipeForm.get('steps').dirty || this.deleteStepsList.length > 0;\n    return ingChange || stepChange;\n  }\n\n  /**\n   * Update or create Recipe\n   * it can only update changed part of a recipe\n   */\n  private upsertRecipe(): Observable<Recipe> {\n    // break upsert : we have to choose beetwen relationships and this field\n    delete this.recipe.attributes[`ingredients-str`];\n    delete this.recipe.attributes[`suggested`];\n    delete this.recipe.attributes[`popularity`];\n    this.handleRecipeStatusWorkflow();\n    this.setRelationShipIfFormPartIsDirty('recipe-type');\n    this.setRelationShipIfFormPartIsDirty('recipe-status');\n    this.setRelationShipIfFormPartIsDirty('recipe-provider');\n    if (this.customSubmitCallback) {\n      this.recipe.attributes = { ... this.recipe.attributes, ...this.recipeForm.getRawValue().attributes };\n      this.recipeChange.emit(this.recipe);\n      this.recipeForm.get('attributes').markAsDirty();\n      this.isSubmiting = false;\n      return of(null);\n    }\n    if (this.recipeForm.get('attributes')?.dirty) {\n      return this.updateRecipeAttributes().pipe(\n        switchMap(recipe => {\n          // may be a creation or an update, anyway updateRecipeAttributes return the final recipe\n          // we update the current recipe, usefull in case of creation as it is undefined until now\n          if (recipe) {\n            this.recipe = recipe;\n          }\n          if (this.relationshipsChanged()) {\n            return this.updateRecipeRelationShips(this.recipe);\n          } else {\n            return of(recipe);\n          }\n        })\n      );\n    } else {\n      // can only be an update, with only relationships modifs\n      return this.updateRecipeRelationShips(this.recipe);\n    }\n  }\n\n  private setRelationShipIfFormPartIsDirty(formPart: string): void {\n    if (this.recipeForm.get(`${formPart}`)?.dirty) {\n      // force full recipe update\n      this.recipeForm.get('attributes').markAsDirty();\n      this.recipe.addRelationship(this.recipeForm.get(`${formPart}`).value, `${formPart}`);\n    }\n  }\n\n  /**\n   * Emit when change has been done back\n   * reset form's states\n   */\n  private handleEmition(recipe: Recipe): void {\n    this.recipeChange.emit(recipe ? recipe : this.recipe);\n    this.recipeForm.markAsPristine();\n  }\n\n  private handleRecipeStatusWorkflow() {\n    // use if we are patching recipe as an non Admin user\n    if (!this.isAdmin && !this.customSubmitCallback) {\n      this.recipeForm.get('recipe-status').patchValue(this.statusService.submittedValue);\n      this.recipeForm.get('recipe-status').markAsDirty();\n    }\n    let formMedia = this.recipeForm.get('attributes').get('media-url');\n    if (!this.recipe.attributes['media-url'] && !formMedia.value) {\n      formMedia.patchValue('https://storage.googleapis.com/assets.miam.tech/generic/personal-recipes/default_img_personal_recipe.jpg')\n    }\n  }\n}\n\n\n","<form *ngIf='recipeForm' [formGroup]=\"recipeForm\" class=\"form-container\">\n  <ng-container [formGroup]=\"recipeForm?.get('attributes')\">\n    <ng-miam-text-input class=\"m-title-text-input\" ngDefaultControl [formControl]=\"recipeForm?.get('attributes')?.get('title')\" placeholder=\"Titre de la recette\"></ng-miam-text-input>\n    <div class=\"row-container\">\n      <div class=\"input-container\">\n        <ng-miam-drag-drop-input ngDefaultControl buttonText='Ajouter une photo'  [formControl]=\"recipeForm?.get('attributes')?.get('media-url')\"\n          [imageUrl]=\"recipeForm?.get('attributes')?.get('media-url')?.value\" [photoMode]='true'>\n        </ng-miam-drag-drop-input>\n        <div class=\"recipe-form__guests m-default-card\">\n          <span class=\"recipe-form__guests__label\">Nombre de convives</span>\n          <ng-miam-counter-input ngDefaultControl formControlName=\"number-of-guests\"\n            [formControl]=\"this.recipeForm.controls['attributes']['controls'][['number-of-guests']]\"\n            counter='4' minRange='0' maxRange='999'>\n          </ng-miam-counter-input>\n        </div>\n      </div>\n      <div class=\"recipe-form__attibutes\">\n        <ng-miam-select-input ngDefaultControl placeholder='Choisir un type' labelPath='attributes.name'\n          [options]=\"recipeTypeService?.getTypes() | async\" [formControl]=\"recipeForm?.get('recipe-type')\">\n        </ng-miam-select-input>\n        <div class=\"recipe-form__attibutes__sliders\">\n          <div class=\"recipe-form__attibutes__slider\">\n            <ng-miam-slider ngDefaultControl [steps]=\"dificulties\"\n              [formControl]=\"recipeForm?.get('attributes')?.get('difficulty')\" [icons]=\"iconsDificulties\">\n            </ng-miam-slider>\n          </div>\n        </div>\n        <div *ngIf='recipeForm' class=\"recipe-form__attibutes__times\">\n          <ng-miam-time-picker ngDefaultControl title='Temps de préparation'\n            [formControl]=\"recipeForm?.get('attributes')?.get('preparation-time')\" [icon]='icon.Time'>\n          </ng-miam-time-picker>\n          <ng-miam-time-picker ngDefaultControl title='Temps de cuisson'\n            [formControl]=\"recipeForm?.get('attributes')?.get('cooking-time')\" [icon]='icon.Hot'></ng-miam-time-picker>\n          <ng-miam-time-picker ngDefaultControl title='Temps de repos'\n            [formControl]=\"recipeForm?.get('attributes')?.get('resting-time')\" [icon]='icon.Wait'></ng-miam-time-picker>\n          <ng-miam-time-picker ngDefaultControl title='Temps de préchauffage'\n            [formControl]=\"recipeForm?.get('attributes')?.get('resting-time')\" [icon]='icon.Preheat'>\n          </ng-miam-time-picker>\n        </div>\n      </div>\n    </div>\n  </ng-container>\n  <div class=\"row-container\">\n    <div class=\"input-container\">\n      <ng-miam-list-input  label=\"Ingrédients\" ngDefaultControl (deleteId)=\"addToDeleteIngredientsList($event)\" [ingredientMode]='true'\n        [list]=\"recipeForm.get('ingredients')\" formArrayName=\"ingredients\" hint='ingrédients'>\n      </ng-miam-list-input>\n    </div>\n    <div class=\"input-container\">\n      <ng-miam-list-input ngDefaultControl label=\"Étapes\" formArrayName=\"steps\" (deleteId)=\"addToDeleteStepsList($event)\"\n        [list]=\"recipeForm.get('steps')\" hint='étapes'></ng-miam-list-input>\n    </div>\n    <div class=\"input-container\" *ngIf=\"isAdmin\">\n\n      <ng-miam-select-input ngDefaultControl placeholder='Choisir un status' labelPath='attributes.name'\n      [options]=\"statuses | async\" [formControl]=\"recipeForm?.get('recipe-status')\">\n      </ng-miam-select-input>\n\n      <ng-miam-select-input ngDefaultControl placeholder='Choisir un provider' labelPath='attributes.name'\n      [options]=\"recipeProviderservice?.providerList | async\"[formControl]=\"recipeForm?.get('recipe-provider')\">\n      </ng-miam-select-input>\n      <textarea cdkTextareaAutosize cdkAutosizeMinRows=\"20\" cdkAutosizeMaxRows=\"50\" class=\"m-input\"\n        [formControl]=\"recipeForm?.get('attributes')?.get('description')\"></textarea>\n    </div>\n  </div>\n\n</form>\n<div class='button-row'>\n  <button class=\"m-button-secondary\" (click)='cancel()'>Annuler</button>\n  <button class=\"m-button-primary\" (click)='submit()' [disabled]='recipeForm?.invalid || !recipeForm?.dirty || isSubmiting'>\n    Enregistrer la recette\n    </button>\n</div>"]}

package/esm2015/lib/_web-components/recipe-helper/recipe-helper.component.js

@@ -1,6 +1,6 @@
 import { MediaMatcher } from '@angular/cdk/layout';
 import { Component, Output, EventEmitter, ChangeDetectionStrategy, ViewEncapsulation, ChangeDetectorRef, Input } from '@angular/core';
-import { RecipesService } from '../../_services';
+import { ContextService, RecipesService } from '../../_services';
 import { Icon } from '../../_types/icon.enum';
 import * as i0 from "@angular/core";
 import * as i1 from "../../_services";
@@ -98,10 +98,11 @@ function RecipeHelperComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵtextInterpolate1(" C'est tout, c'est ajout\u00E9 ! Retrouvez le d\u00E9tail ", ctx_r0.stringDetailLocation, " ");
 } }
 export class RecipeHelperComponent {
-    constructor(cdr, recipesService, mediaMatcher) {
+    constructor(cdr, recipesService, mediaMatcher, context) {
         this.cdr = cdr;
         this.recipesService = recipesService;
         this.mediaMatcher = mediaMatcher;
+        this.context = context;
         this.stringDetailLocation = 'dans l\'onglet Mes Repas';
         this.close = new EventEmitter();
         // @Output() moreInfo = new EventEmitter();
@@ -114,7 +115,7 @@ export class RecipeHelperComponent {
     ngOnInit() {
         this.subscriptions.push(this.recipesService.displayHelper$.subscribe(displayed => {
             this.isDisplayed = displayed;
-            document.body.style.overflow = displayed ? 'hidden' : 'auto';
+            this.context.globalScrollableElement.style.overflow = displayed ? 'hidden' : 'initial';
             this.cdr.detectChanges();
         }));
     }
@@ -129,7 +130,7 @@ export class RecipeHelperComponent {
         this.subscriptions.forEach(sub => sub.unsubscribe());
     }
 }
-RecipeHelperComponent.ɵfac = function RecipeHelperComponent_Factory(t) { return new (t || RecipeHelperComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.RecipesService), i0.ɵɵdirectiveInject(i2.MediaMatcher)); };
+RecipeHelperComponent.ɵfac = function RecipeHelperComponent_Factory(t) { return new (t || RecipeHelperComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.RecipesService), i0.ɵɵdirectiveInject(i2.MediaMatcher), i0.ɵɵdirectiveInject(i1.ContextService)); };
 RecipeHelperComponent.ɵcmp = i0.ɵɵdefineComponent({ type: RecipeHelperComponent, selectors: [["ng-miam-recipe-helper"]], inputs: { stringDetailLocation: "stringDetailLocation" }, outputs: { close: "close" }, decls: 1, vars: 1, consts: [[4, "ngIf"], [1, "miam-shadow-overlay", 3, "click"], [1, "miam-recipe-helper"], [1, "miam-recipe-helper__header"], [3, "width", "height", "iconName", 4, "ngIf", "ngIfElse"], ["mobileIcon", ""], [1, "miam-recipe-helper__title"], [1, "miam-recipe-helper__description"], [1, "miam-recipe-helper__how"], [1, "miam-recipe-helper__step"], [1, "miam-recipe-helper__step__number"], [1, "miam-recipe-helper__step__description"], [1, "m-button-fab-primary", "miam-recipe-helper__step__icon"], ["primaryColor", "var(--m-color-white)", 3, "width", "height", "iconName"], [1, "miam-recipe-helper__actions"], [1, "m-button-secondary", 3, "click"], [3, "width", "height", "iconName"]], template: function RecipeHelperComponent_Template(rf, ctx) { if (rf & 1) {
         i0.ɵɵtemplate(0, RecipeHelperComponent_ng_container_0_Template, 41, 6, "ng-container", 0);
     } if (rf & 2) {
@@ -144,9 +145,9 @@ RecipeHelperComponent.ɵcmp = i0.ɵɵdefineComponent({ type: RecipeHelperCompone
                 encapsulation: ViewEncapsulation.None,
                 changeDetection: ChangeDetectionStrategy.OnPush
             }]
-    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.RecipesService }, { type: i2.MediaMatcher }]; }, { stringDetailLocation: [{
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.RecipesService }, { type: i2.MediaMatcher }, { type: i1.ContextService }]; }, { stringDetailLocation: [{
             type: Input
         }], close: [{
             type: Output
         }] }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipe-helper.component.js","sourceRoot":"/builds/miam/ng-miam-sdk/projects/ng-miam/src/","sources":["lib/_web-components/recipe-helper/recipe-helper.component.ts","lib/_web-components/recipe-helper/recipe-helper.component.html"],"names":[],"mappings":"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","sourcesContent":["import { MediaMatcher } from '@angular/cdk/layout';\nimport { Component, Output, EventEmitter, ChangeDetectionStrategy, ViewEncapsulation, ChangeDetectorRef, OnInit, OnDestroy, Input } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { RecipesService } from '../../_services';\nimport { Icon } from '../../_types/icon.enum';\n\n@Component({\n  selector: 'ng-miam-recipe-helper',\n  templateUrl: './recipe-helper.component.html',\n  styleUrls: ['./recipe-helper.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class RecipeHelperComponent implements OnInit, OnDestroy {\n  @Input() stringDetailLocation = 'dans l\\'onglet Mes Repas';\n  @Output() close = new EventEmitter();\n  // @Output() moreInfo = new EventEmitter();\n\n  icon = Icon;\n  isMobile = false;\n  isDisplayed = false;\n  protected subscriptions: Subscription[];\n\n  constructor(\n    private cdr: ChangeDetectorRef,\n    private recipesService: RecipesService,\n    private mediaMatcher: MediaMatcher,\n  ) {\n    this.subscriptions = [];\n    this.isMobile = this.mediaMatcher.matchMedia('(min-width: 1023px)').matches;\n   }\n\n  ngOnInit() {\n    this.subscriptions.push(this.recipesService.displayHelper$.subscribe(displayed => {\n      this.isDisplayed = displayed;\n      document.body.style.overflow = displayed ? 'hidden' : 'auto';\n      this.cdr.detectChanges();\n    }));\n  }\n\n  onClose() {\n    this.recipesService.toggleHelper();\n    this.close.emit();\n  }\n\n  // onMoreInfo() {\n  //   this.moreInfo.emit();\n  // }\n\n  ngOnDestroy() {\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n}\n","<ng-container *ngIf=\"isDisplayed\">\n  <div (click)=\"onClose()\" class=\"miam-shadow-overlay\"></div>\n  \n  <div class=\"miam-recipe-helper\">\n    <div class=\"miam-recipe-helper__header\">\n      <ng-miam-icon *ngIf=\"isMobile else mobileIcon\" [width]=\"128\" [height]=\"128\" [iconName]=\"icon.RecipeHelp\"></ng-miam-icon>\n      <ng-template #mobileIcon>\n        <ng-miam-icon  [width]=\"95\" [height]=\"95\" [iconName]=\"icon.RecipeHelp\"></ng-miam-icon>\n      </ng-template>\n    </div>\n    <div class=\"miam-recipe-helper__title\">Faire mes courses à partir de recettes</div>\n    <div class=\"miam-recipe-helper__description\">\n      Dorénavant faites vos courses à partir de recettes et ajoutez les ingrédients en 1 clic !\n    </div>\n  \n    <div class=\"miam-recipe-helper__how\">Comment ça marche ?</div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">1</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        Retrouvez le détail de la recette en cliquant sur le titre\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">2</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        Ajustez le nombre de convives si nécessaire\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">3</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        <span>Cliquez sur Sélectionner ce repas</span> \n        <span class=\"m-button-fab-primary miam-recipe-helper__step__icon\">\n          <ng-miam-icon [width]=\"14\" [height]=\"14\" primaryColor='var(--m-color-white)'\n          [iconName]=\"icon.Cart\"></ng-miam-icon>\n        </span>\n        <span>et ajustez les produits si besoin</span>\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">4</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        C'est tout, c'est ajouté ! Retrouvez le détail {{stringDetailLocation}}\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__actions\">\n      <button (click)=\"onClose()\" class=\"m-button-secondary\">\n        Fermer\n      </button>\n      <!-- <button (click)=\"onMoreInfo()\" class=\"m-button-primary miam-recipe-helper__actions__moreInfo\">\n        Plus d'informations\n      </button> -->\n    </div>\n  </div>\n</ng-container>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipe-helper.component.js","sourceRoot":"/builds/miam/ng-miam-sdk/projects/ng-miam/src/","sources":["lib/_web-components/recipe-helper/recipe-helper.component.ts","lib/_web-components/recipe-helper/recipe-helper.component.html"],"names":[],"mappings":"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","sourcesContent":["import { MediaMatcher } from '@angular/cdk/layout';\nimport { Component, Output, EventEmitter, ChangeDetectionStrategy, ViewEncapsulation, ChangeDetectorRef, OnInit, OnDestroy, Input } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { ContextService, RecipesService } from '../../_services';\nimport { Icon } from '../../_types/icon.enum';\n\n@Component({\n  selector: 'ng-miam-recipe-helper',\n  templateUrl: './recipe-helper.component.html',\n  styleUrls: ['./recipe-helper.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class RecipeHelperComponent implements OnInit, OnDestroy {\n  @Input() stringDetailLocation = 'dans l\\'onglet Mes Repas';\n  @Output() close = new EventEmitter();\n  // @Output() moreInfo = new EventEmitter();\n\n  icon = Icon;\n  isMobile = false;\n  isDisplayed = false;\n  protected subscriptions: Subscription[];\n\n  constructor(\n    private cdr: ChangeDetectorRef,\n    private recipesService: RecipesService,\n    private mediaMatcher: MediaMatcher,\n    private context: ContextService\n  ) {\n    this.subscriptions = [];\n    this.isMobile = this.mediaMatcher.matchMedia('(min-width: 1023px)').matches;\n   }\n\n  ngOnInit() {\n    this.subscriptions.push(this.recipesService.displayHelper$.subscribe(displayed => {\n      this.isDisplayed = displayed;\n      this.context.globalScrollableElement.style.overflow = displayed ? 'hidden' : 'initial';\n      this.cdr.detectChanges();\n    }));\n  }\n\n  onClose() {\n    this.recipesService.toggleHelper();\n    this.close.emit();\n  }\n\n  // onMoreInfo() {\n  //   this.moreInfo.emit();\n  // }\n\n  ngOnDestroy() {\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n}\n","<ng-container *ngIf=\"isDisplayed\">\n  <div (click)=\"onClose()\" class=\"miam-shadow-overlay\"></div>\n  \n  <div class=\"miam-recipe-helper\">\n    <div class=\"miam-recipe-helper__header\">\n      <ng-miam-icon *ngIf=\"isMobile else mobileIcon\" [width]=\"128\" [height]=\"128\" [iconName]=\"icon.RecipeHelp\"></ng-miam-icon>\n      <ng-template #mobileIcon>\n        <ng-miam-icon  [width]=\"95\" [height]=\"95\" [iconName]=\"icon.RecipeHelp\"></ng-miam-icon>\n      </ng-template>\n    </div>\n    <div class=\"miam-recipe-helper__title\">Faire mes courses à partir de recettes</div>\n    <div class=\"miam-recipe-helper__description\">\n      Dorénavant faites vos courses à partir de recettes et ajoutez les ingrédients en 1 clic !\n    </div>\n  \n    <div class=\"miam-recipe-helper__how\">Comment ça marche ?</div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">1</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        Retrouvez le détail de la recette en cliquant sur le titre\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">2</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        Ajustez le nombre de convives si nécessaire\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">3</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        <span>Cliquez sur Sélectionner ce repas</span> \n        <span class=\"m-button-fab-primary miam-recipe-helper__step__icon\">\n          <ng-miam-icon [width]=\"14\" [height]=\"14\" primaryColor='var(--m-color-white)'\n          [iconName]=\"icon.Cart\"></ng-miam-icon>\n        </span>\n        <span>et ajustez les produits si besoin</span>\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__step\">\n      <div class=\"miam-recipe-helper__step__number\">4</div>\n      <div class=\"miam-recipe-helper__step__description\">\n        C'est tout, c'est ajouté ! Retrouvez le détail {{stringDetailLocation}}\n      </div>\n    </div>\n    <div class=\"miam-recipe-helper__actions\">\n      <button (click)=\"onClose()\" class=\"m-button-secondary\">\n        Fermer\n      </button>\n      <!-- <button (click)=\"onMoreInfo()\" class=\"m-button-primary miam-recipe-helper__actions__moreInfo\">\n        Plus d'informations\n      </button> -->\n    </div>\n  </div>\n</ng-container>"]}

package/esm2015/lib/_web-components/recipe-modal/recipe-modal.component.js

@@ -1,8 +1,6 @@
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, ViewChild } from '@angular/core';
-import { filter } from 'rxjs/operators';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef } from '@angular/core';
 import { GroceriesListsService, RecipesService } from '../../_services';
 import { PrintService } from '../../_services/print.service';
-import { RecipeDetailsComponent } from '../recipe-details/recipe-details.component';
 import * as i0 from "@angular/core";
 import * as i1 from "../../_services";
 import * as i2 from "../../_services/print.service";
@@ -10,7 +8,6 @@ import * as i3 from "../modal/modal.component";
 import * as i4 from "@angular/common";
 import * as i5 from "../recipe-details/recipe-details.component";
 import * as i6 from "../basket-preview/basket-preview-block/basket-preview-block.component";
-const _c0 = ["details"];
 function RecipeModalComponent_ng_miam_recipe_details_1_Template(rf, ctx) { if (rf & 1) {
     const _r4 = i0.ɵɵgetCurrentView();
     i0.ɵɵelementStart(0, "ng-miam-recipe-details", 3, 4);
@@ -32,7 +29,6 @@ function RecipeModalComponent_div_2_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵadvance(1);
     i0.ɵɵproperty("recipeId", ctx_r1.recipe && ctx_r1.recipe.id);
 } }
-const _c1 = function (a0) { return { "hiddeCloseIcon": a0 }; };
 export class RecipeModalComponent {
     constructor(cdr, recipesService, printService, elRef, groceriesListsService) {
         this.cdr = cdr;
@@ -43,28 +39,25 @@ export class RecipeModalComponent {
         this.show = false;
         this.previewMode = false;
     }
-    set content(content) {
-        if (content) {
-            this.detailsComponent = content;
-            this.detailsComponent.closeIconhidden.subscribe(isHide => {
-                this.closeIconhidden = isHide;
-                this.cdr.detectChanges();
-            });
-        }
-    }
     ngOnInit() {
-        this.recipesService.displayedRecipe$.pipe(filter(result => !!(result === null || result === void 0 ? void 0 : result.recipe))).subscribe(result => {
+        this.recipesService.displayedRecipe$.subscribe(result => {
             var _a;
-            this.recipe = result.recipe;
-            this.previewMode = result.previewMode;
-            this.previewAllowed = result.previewAllowed;
-            this.show = true;
-            this.printService.prepareForPrint(this.elRef);
-            (_a = this.detailsComponent) === null || _a === void 0 ? void 0 : _a.cdr.markForCheck();
-            if (this.detailsComponent) {
-                this.detailsComponent.showDetail = true;
+            if (!(result === null || result === void 0 ? void 0 : result.recipe)) {
+                this.show = false;
+                this.cdr.detectChanges();
+            }
+            else {
+                this.recipe = result.recipe;
+                this.previewMode = result.previewMode;
+                this.previewAllowed = result.previewAllowed;
+                this.show = true;
+                this.printService.prepareForPrint(this.elRef);
+                (_a = this.detailsComponent) === null || _a === void 0 ? void 0 : _a.cdr.markForCheck();
+                if (this.detailsComponent) {
+                    this.detailsComponent.showDetail = true;
+                }
+                this.cdr.detectChanges();
             }
-            this.cdr.detectChanges();
         });
     }
     hide() {
@@ -75,7 +68,6 @@ export class RecipeModalComponent {
         this.cdr.detectChanges();
     }
     togglePreviewMode() {
-        this.closeIconhidden = false;
         this.previewMode = !this.previewMode;
         this.cdr.detectChanges();
     }
@@ -97,24 +89,19 @@ export class RecipeModalComponent {
     }
 }
 RecipeModalComponent.ɵfac = function RecipeModalComponent_Factory(t) { return new (t || RecipeModalComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.RecipesService), i0.ɵɵdirectiveInject(i2.PrintService), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.GroceriesListsService)); };
-RecipeModalComponent.ɵcmp = i0.ɵɵdefineComponent({ type: RecipeModalComponent, selectors: [["ng-miam-recipe-modal"]], viewQuery: function RecipeModalComponent_Query(rf, ctx) { if (rf & 1) {
-        i0.ɵɵviewQuery(_c0, true);
-    } if (rf & 2) {
-        var _t;
-        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.content = _t.first);
-    } }, decls: 3, vars: 12, consts: [[3, "ngClass", "isAngularComponent", "noHeaderMode", "expanded", "title", "cancelButtonText", "confirmButtonText", "expandedChange", "close", "cancel", "confirm"], [3, "recipe", "previewAllowed", "recipeAdded", "recipeChanged", "recipeError", 4, "ngIf"], ["class", "miam-wrapper-preview", 4, "ngIf"], [3, "recipe", "previewAllowed", "recipeAdded", "recipeChanged", "recipeError"], ["details", ""], [1, "miam-wrapper-preview"], [3, "recipeId", "guestCountChanged"]], template: function RecipeModalComponent_Template(rf, ctx) { if (rf & 1) {
+RecipeModalComponent.ɵcmp = i0.ɵɵdefineComponent({ type: RecipeModalComponent, selectors: [["ng-miam-recipe-modal"]], decls: 3, vars: 9, consts: [[3, "isAngularComponent", "noHeaderMode", "expanded", "title", "cancelButtonText", "confirmButtonText", "expandedChange", "close", "cancel", "confirm"], [3, "recipe", "previewAllowed", "recipeAdded", "recipeChanged", "recipeError", 4, "ngIf"], ["class", "miam-wrapper-preview", 4, "ngIf"], [3, "recipe", "previewAllowed", "recipeAdded", "recipeChanged", "recipeError"], ["details", ""], [1, "miam-wrapper-preview"], [3, "recipeId", "guestCountChanged"]], template: function RecipeModalComponent_Template(rf, ctx) { if (rf & 1) {
         i0.ɵɵelementStart(0, "ng-miam-modal", 0);
         i0.ɵɵlistener("expandedChange", function RecipeModalComponent_Template_ng_miam_modal_expandedChange_0_listener($event) { return ctx.show = $event; })("close", function RecipeModalComponent_Template_ng_miam_modal_close_0_listener() { return ctx.hide(); })("cancel", function RecipeModalComponent_Template_ng_miam_modal_cancel_0_listener() { return ctx.removeRecipe(); })("confirm", function RecipeModalComponent_Template_ng_miam_modal_confirm_0_listener() { return ctx.hide(); });
         i0.ɵɵtemplate(1, RecipeModalComponent_ng_miam_recipe_details_1_Template, 2, 2, "ng-miam-recipe-details", 1);
         i0.ɵɵtemplate(2, RecipeModalComponent_div_2_Template, 2, 1, "div", 2);
         i0.ɵɵelementEnd();
     } if (rf & 2) {
-        i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(10, _c1, ctx.closeIconhidden))("isAngularComponent", true)("noHeaderMode", true)("expanded", ctx.show)("noHeaderMode", !ctx.previewMode)("title", ctx.previewMode ? "1 repas ajout\u00E9 \u00E0 votre panier :" : "")("cancelButtonText", ctx.previewMode ? "Retirer le repas" : "")("confirmButtonText", ctx.previewMode ? "Ok, continuer mes courses" : "");
+        i0.ɵɵproperty("isAngularComponent", true)("noHeaderMode", true)("expanded", ctx.show)("noHeaderMode", !ctx.previewMode)("title", ctx.previewMode ? "1 repas ajout\u00E9 \u00E0 votre panier :" : "")("cancelButtonText", ctx.previewMode ? "Retirer le repas" : "")("confirmButtonText", ctx.previewMode ? "Ok, continuer mes courses" : "");
         i0.ɵɵadvance(1);
         i0.ɵɵproperty("ngIf", ctx.recipe && !ctx.previewMode);
         i0.ɵɵadvance(1);
         i0.ɵɵproperty("ngIf", ctx.previewMode);
-    } }, directives: [i3.ModalComponent, i4.NgClass, i4.NgIf, i5.RecipeDetailsComponent, i6.BasketPreviewBlockComponent], styles: [".miam-wrapper-preview[_ngcontent-%COMP%]{background-color:#fff;flex:1;overflow-y:auto;padding:20px}@media (max-width:1022px){.miam-wrapper-preview[_ngcontent-%COMP%]{padding-bottom:80px}}.miam-wrapper-preview[_ngcontent-%COMP%]::-webkit-scrollbar{cursor:-webkit-grab;height:7px;width:5px}.miam-wrapper-preview[_ngcontent-%COMP%]::-webkit-scrollbar-track{background:var(--m-color-grey)}.miam-wrapper-preview[_ngcontent-%COMP%]::-webkit-scrollbar-thumb{background:var(--m-color-primary);border-radius:5px}.hiddeCloseIcon[_ngcontent-%COMP%]     .miam-modal .miam-modal__container .miam-modal__header{display:none}"], changeDetection: 0 });
+    } }, directives: [i3.ModalComponent, i4.NgIf, i5.RecipeDetailsComponent, i6.BasketPreviewBlockComponent], styles: [".miam-wrapper-preview[_ngcontent-%COMP%]{background-color:#fff;flex:1;overflow-y:auto;padding:20px}@media (max-width:1022px){.miam-wrapper-preview[_ngcontent-%COMP%]{padding-bottom:80px}}.miam-wrapper-preview[_ngcontent-%COMP%]::-webkit-scrollbar{cursor:-webkit-grab;height:7px;width:5px}.miam-wrapper-preview[_ngcontent-%COMP%]::-webkit-scrollbar-track{background:var(--m-color-grey)}.miam-wrapper-preview[_ngcontent-%COMP%]::-webkit-scrollbar-thumb{background:var(--m-color-primary);border-radius:5px}"], changeDetection: 0 });
 /*@__PURE__*/ (function () { i0.ɵsetClassMetadata(RecipeModalComponent, [{
         type: Component,
         args: [{
@@ -123,8 +110,5 @@ RecipeModalComponent.ɵcmp = i0.ɵɵdefineComponent({ type: RecipeModalComponent
                 styleUrls: ['./recipe-modal.component.scss'],
                 changeDetection: ChangeDetectionStrategy.OnPush
             }]
-    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.RecipesService }, { type: i2.PrintService }, { type: i0.ElementRef }, { type: i1.GroceriesListsService }]; }, { content: [{
-            type: ViewChild,
-            args: ['details']
-        }] }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipe-modal.component.js","sourceRoot":"/builds/miam/ng-miam-sdk/projects/ng-miam/src/","sources":["lib/_web-components/recipe-modal/recipe-modal.component.ts","lib/_web-components/recipe-modal/recipe-modal.component.html"],"names":[],"mappings":"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","sourcesContent":["import {ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, OnInit, ViewChild } from '@angular/core';\nimport { filter } from 'rxjs/operators';\nimport { Recipe } from '../../_models';\nimport { GroceriesListsService, RecipesService } from '../../_services';\nimport { PrintService } from '../../_services/print.service';\nimport { RecipeDetailsComponent } from '../recipe-details/recipe-details.component';\n\n@Component({\n  selector: 'ng-miam-recipe-modal',\n  templateUrl: './recipe-modal.component.html',\n  styleUrls: ['./recipe-modal.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class RecipeModalComponent implements OnInit {\n  recipe: Recipe;\n  show = false;\n  previewMode = false;\n  previewAllowed: boolean;\n  closeIconhidden: boolean;\n\n  private detailsComponent: RecipeDetailsComponent;\n\n\n  @ViewChild('details') set content(content: RecipeDetailsComponent) {\n    if (content) {\n        this.detailsComponent = content;\n        this.detailsComponent.closeIconhidden.subscribe( isHide => {\n          this.closeIconhidden = isHide;\n          this.cdr.detectChanges();\n        });\n    }\n }\n\n  constructor(\n    private cdr: ChangeDetectorRef,\n    public recipesService: RecipesService,\n    private printService: PrintService,\n    private elRef: ElementRef,\n    private groceriesListsService: GroceriesListsService\n  ) { }\n\n  ngOnInit(): void {\n    this.recipesService.displayedRecipe$.pipe(\n      filter(result => !!result?.recipe)\n    ).subscribe(result => {\n      this.recipe = result.recipe;\n      this.previewMode = result.previewMode;\n      this.previewAllowed = result.previewAllowed;\n      this.show = true;\n      this.printService.prepareForPrint(this.elRef);\n      this.detailsComponent?.cdr.markForCheck();\n      if (this.detailsComponent) { this.detailsComponent.showDetail = true; }\n      this.cdr.detectChanges();\n    });\n  }\n\n  hide() {\n    this.show = false;\n    this.previewMode = false;\n    this.recipesService.hide();\n    this.printService.dissmissPrinting();\n    this.cdr.detectChanges();\n  }\n\n  togglePreviewMode() {\n    this.closeIconhidden = false;\n    this.previewMode = !this.previewMode;\n    this.cdr.detectChanges();\n  }\n\n  removeRecipe() {\n    this.groceriesListsService.removeRecipeFromList(this.recipe.id).subscribe();\n    this.hide();\n  }\n\n  updateRecipeGuests(guests: number) {\n    this.recipe.modifiedGuests = guests;\n  }\n\n  // If the recipe is already in basket, update the number of guests (= append recipe to list again)\n  recipeChanged() {\n    this.groceriesListsService.recipeIsInList(this.recipe.id).subscribe(recipeIsInList => {\n      if (recipeIsInList) {\n        this.groceriesListsService.appendRecipeToList(this.recipe.id, this.recipe.modifiedGuests, 'recipe-modal').subscribe();\n      }\n    });\n    this.recipesService.displayedRecipeChanged.emit();\n  }\n}\n","<ng-miam-modal \n  [ngClass]=\"{'hiddeCloseIcon': closeIconhidden}\"\n  [isAngularComponent]=\"true\" \n  [noHeaderMode]=\"true\"\n  [(expanded)]=\"show\"\n  [noHeaderMode]='!previewMode' \n  [title]=\"previewMode ? '1 repas ajouté à votre panier :' : ''\"\n  [cancelButtonText]=\"previewMode ? 'Retirer le repas' : ''\"\n  [confirmButtonText]=\"previewMode ? 'Ok, continuer mes courses' : ''\"\n  (close)=\"hide()\"\n  (cancel)=\"removeRecipe()\"\n  (confirm)=\"hide()\"\n>\n  <ng-miam-recipe-details\n    #details\n    *ngIf=\"recipe && !previewMode\"\n    [recipe]=\"recipe\"\n    [previewAllowed]=\"previewAllowed\"\n    (recipeAdded)=\"togglePreviewMode()\"\n    (recipeChanged)=\"recipeChanged()\"\n    (recipeError)=\"hide()\"\n  ></ng-miam-recipe-details>\n\n  <div class=\"miam-wrapper-preview\" *ngIf=\"previewMode\">\n    <ng-miam-basket-preview-block\n      [recipeId]=\"recipe && recipe.id\"\n      (guestCountChanged)=\"updateRecipeGuests($event)\"\n    ></ng-miam-basket-preview-block>\n  </div>\n</ng-miam-modal>"]}
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.RecipesService }, { type: i2.PrintService }, { type: i0.ElementRef }, { type: i1.GroceriesListsService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recipe-modal.component.js","sourceRoot":"/builds/miam/ng-miam-sdk/projects/ng-miam/src/","sources":["lib/_web-components/recipe-modal/recipe-modal.component.ts","lib/_web-components/recipe-modal/recipe-modal.component.html"],"names":[],"mappings":"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","sourcesContent":["import {ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, OnInit, ViewChild } from '@angular/core';\nimport { filter } from 'rxjs/operators';\nimport { Recipe } from '../../_models';\nimport { GroceriesListsService, RecipesService } from '../../_services';\nimport { PrintService } from '../../_services/print.service';\nimport { RecipeDetailsComponent } from '../recipe-details/recipe-details.component';\n\n@Component({\n  selector: 'ng-miam-recipe-modal',\n  templateUrl: './recipe-modal.component.html',\n  styleUrls: ['./recipe-modal.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class RecipeModalComponent implements OnInit {\n  recipe: Recipe;\n  show = false;\n  previewMode = false;\n  previewAllowed: boolean;\n\n  private detailsComponent: RecipeDetailsComponent;\n\n  constructor(\n    private cdr: ChangeDetectorRef,\n    public recipesService: RecipesService,\n    private printService: PrintService,\n    private elRef: ElementRef,\n    private groceriesListsService: GroceriesListsService\n  ) { }\n\n  ngOnInit(): void {\n    this.recipesService.displayedRecipe$.subscribe(result => {\n      if (!result?.recipe) {\n        this.show = false;\n        this.cdr.detectChanges();\n      }\n      else {\n        this.recipe = result.recipe;\n        this.previewMode = result.previewMode;\n        this.previewAllowed = result.previewAllowed;\n        this.show = true;\n        this.printService.prepareForPrint(this.elRef);\n        this.detailsComponent?.cdr.markForCheck();\n        if (this.detailsComponent) { this.detailsComponent.showDetail = true; }\n        this.cdr.detectChanges();\n      }\n    });\n  }\n\n  hide() {\n    this.show = false;\n    this.previewMode = false;\n    this.recipesService.hide();\n    this.printService.dissmissPrinting();\n    this.cdr.detectChanges();\n  }\n\n  togglePreviewMode() {\n    this.previewMode = !this.previewMode;\n    this.cdr.detectChanges();\n  }\n\n  removeRecipe() {\n    this.groceriesListsService.removeRecipeFromList(this.recipe.id).subscribe();\n    this.hide();\n  }\n\n  updateRecipeGuests(guests: number) {\n    this.recipe.modifiedGuests = guests;\n  }\n\n  // If the recipe is already in basket, update the number of guests (= append recipe to list again)\n  recipeChanged() {\n    this.groceriesListsService.recipeIsInList(this.recipe.id).subscribe(recipeIsInList => {\n      if (recipeIsInList) {\n        this.groceriesListsService.appendRecipeToList(this.recipe.id, this.recipe.modifiedGuests, 'recipe-modal').subscribe();\n      }\n    });\n    this.recipesService.displayedRecipeChanged.emit();\n  }\n}\n","<ng-miam-modal \n  [isAngularComponent]=\"true\" \n  [noHeaderMode]=\"true\"\n  [(expanded)]=\"show\"\n  [noHeaderMode]='!previewMode' \n  [title]=\"previewMode ? '1 repas ajouté à votre panier :' : ''\"\n  [cancelButtonText]=\"previewMode ? 'Retirer le repas' : ''\"\n  [confirmButtonText]=\"previewMode ? 'Ok, continuer mes courses' : ''\"\n  (close)=\"hide()\"\n  (cancel)=\"removeRecipe()\"\n  (confirm)=\"hide()\"\n>\n  <ng-miam-recipe-details\n    #details\n    *ngIf=\"recipe && !previewMode\"\n    [recipe]=\"recipe\"\n    [previewAllowed]=\"previewAllowed\"\n    (recipeAdded)=\"togglePreviewMode()\"\n    (recipeChanged)=\"recipeChanged()\"\n    (recipeError)=\"hide()\"\n  ></ng-miam-recipe-details>\n\n  <div class=\"miam-wrapper-preview\" *ngIf=\"previewMode\">\n    <ng-miam-basket-preview-block\n      [recipeId]=\"recipe && recipe.id\"\n      (guestCountChanged)=\"updateRecipeGuests($event)\"\n    ></ng-miam-basket-preview-block>\n  </div>\n</ng-miam-modal>"]}