@rocketshow/designer 1.32.0 → 1.35.0

package/esm2022/lib/preview/preview.component.mjs

@@ -0,0 +1,219 @@
+import { Component, ElementRef, HostListener, ViewChild } from '@angular/core';
+import * as THREE from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
+import { FixtureCategory } from '../models/fixture-profile';
+import { FixtureService } from '../services/fixture.service';
+import { PreviewMeshService } from '../services/preview-mesh.service';
+import { PreviewService } from '../services/preview.service';
+import { ProjectService } from '../services/project.service';
+import { TimelineService } from '../services/timeline.service';
+import { Positioning } from './../models/fixture';
+import { AnimationService } from './../services/animation.service';
+import { ColorChanger3d } from './models/color-changer-3d';
+import { MovingHead3d } from './models/moving-head-3d';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/fixture.service";
+import * as i2 from "../services/preview-mesh.service";
+import * as i3 from "./../services/animation.service";
+import * as i4 from "../services/preview.service";
+import * as i5 from "../services/timeline.service";
+import * as i6 from "../services/project.service";
+const _c0 = ["canvas"];
+export class PreviewComponent {
+    constructor(fixtureService, previewMeshService, animationService, previewService, timelineService, projectService) {
+        this.fixtureService = fixtureService;
+        this.previewMeshService = previewMeshService;
+        this.animationService = animationService;
+        this.previewService = previewService;
+        this.timelineService = timelineService;
+        this.projectService = projectService;
+        this.fixtures3d = [];
+        this.previewService.doUpdateFixtureSetup.subscribe(() => {
+            this.syncFixtures();
+        });
+        this.syncFixtures();
+    }
+    // synchronize the 3d-fixtures to the project fixtures
+    syncFixtures() {
+        if (!this.previewService.scene) {
+            return;
+        }
+        // remove all fixtures
+        for (const fixture3d of this.fixtures3d) {
+            fixture3d.destroy();
+        }
+        this.fixtures3d = [];
+        // add all fixtures from the project
+        for (const fixture of this.fixtureService.cachedFixtures) {
+            switch (fixture.profile.categories[0]) {
+                case FixtureCategory['Moving Head']:
+                    this.fixtures3d.push(new MovingHead3d(this.fixtureService, this.previewMeshService, fixture, this.scene));
+                    break;
+                case FixtureCategory['Color Changer']:
+                    this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));
+                    break;
+                case FixtureCategory['Blinder']:
+                    this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));
+                    break;
+            }
+        }
+    }
+    get canvas() {
+        return this.canvasRef.nativeElement;
+    }
+    render() {
+        this.renderer.render(this.scene, this.camera);
+    }
+    updateStagePosition(positioning, xMin, xMax, yMin, yMax, zMin, zMax) {
+        let positionCount = 0; // Number of fixtures in the same position
+        let positionIndex = 1;
+        this.projectService.project.presetFixtures.forEach((element, index) => {
+            const fixture = this.fixtureService.getFixtureByUuid(element.fixtureUuid);
+            if (fixture.positioning === positioning) {
+                positionCount++;
+            }
+        });
+        this.projectService.project.presetFixtures.forEach((element, index) => {
+            const fixture = this.fixtureService.getFixtureByUuid(element.fixtureUuid);
+            if (fixture.positioning === positioning) {
+                fixture.positionX = xMin + ((xMax - xMin) / (positionCount + 1)) * positionIndex;
+                fixture.positionY = yMin + ((yMax - yMin) / (positionCount + 1)) * positionIndex;
+                fixture.positionZ = zMin + ((zMax - zMin) / (positionCount + 1)) * positionIndex;
+                positionIndex++;
+            }
+        });
+    }
+    animate(timeMillis) {
+        if (this.timelineService.playState === 'playing') {
+            // Overwrite the current time with the playing time, if we're in playback mode
+            timeMillis = this.timelineService.waveSurfer.getCurrentTime() * 1000;
+        }
+        this.animationService.timeMillis = timeMillis;
+        // Update the controls
+        if (this.controls) {
+            this.controls.update();
+        }
+        // Update the positions
+        this.updateStagePosition(Positioning.topFront, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageDepthCm / 2 - 70, this.projectService.project.stageDepthCm / 2 - 70);
+        this.updateStagePosition(Positioning.bottomFront, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageFloorHeightCm, this.projectService.project.stageFloorHeightCm, this.projectService.project.stageDepthCm / 2 - 70, this.projectService.project.stageDepthCm / 2 - 70);
+        this.updateStagePosition(Positioning.topBack, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm, -this.projectService.project.stageDepthCm / 2 + 70, -this.projectService.project.stageDepthCm / 2 + 70);
+        this.updateStagePosition(Positioning.bottomBack, -this.projectService.project.stageWidthCm / 2, this.projectService.project.stageWidthCm / 2, this.projectService.project.stageFloorHeightCm, this.projectService.project.stageFloorHeightCm, -this.projectService.project.stageDepthCm / 2 + 70, -this.projectService.project.stageDepthCm / 2 + 70);
+        // Update all fixtures and apply the preview properties, if available
+        // TODO Update the fixtures only e.g. 40 times per second according to the "real" refresh rate of the DMX interface?
+        const presets = this.previewService.getPresets(timeMillis);
+        const calculatedFixtures = this.previewService.getChannelValues(timeMillis, presets);
+        for (const fixture3d of this.fixtures3d) {
+            // Update the fixture properties
+            fixture3d.updatePreview(calculatedFixtures.get(fixture3d.fixture) || [], this.projectService.project.masterDimmerValue);
+            // Select the fixture, if required
+            if (this.fixtureService.settingsSelection) {
+                fixture3d.isSelected = this.fixtureService.settingsFixtureIsSelected(fixture3d.fixture.fixture);
+            }
+            else {
+                fixture3d.isSelected = this.previewService.fixtureIsSelected(fixture3d.fixture.fixture.uuid, fixture3d.fixture.pixelKey, presets);
+            }
+        }
+        // TODO enable for monitoring the DMX universes
+        this.previewService.setUniverseValues(calculatedFixtures, this.projectService.project.masterDimmerValue);
+        // Render the scene
+        this.render();
+        requestAnimationFrame(this.animate.bind(this));
+    }
+    getAspectRatio() {
+        const height = this.canvas.clientHeight;
+        if (height === 0) {
+            return 0;
+        }
+        return this.canvas.clientWidth / this.canvas.clientHeight;
+    }
+    onResize() {
+        this.camera.aspect = this.getAspectRatio();
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);
+    }
+    setupRenderer() {
+        this.renderer = new THREE.WebGLRenderer({ antialias: true });
+        this.canvas.appendChild(this.renderer.domElement);
+        this.renderer.setPixelRatio(devicePixelRatio);
+        this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);
+        // this.renderer.shadowMap.enabled = true;
+        // this.renderer.gammaInput = true;
+        // this.renderer.gammaOutput = true;
+    }
+    setupCamera() {
+        this.camera = new THREE.PerspectiveCamera(35, window.innerWidth / window.innerHeight, 1, 10000);
+        this.camera.position.set(-600, 80, 700);
+    }
+    setupControls() {
+        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        this.controls.enableKeys = false;
+        this.controls.rotateSpeed = 0.05;
+        this.controls.zoomSpeed = 1.2;
+        this.controls.enableDamping = true;
+        this.controls.dampingFactor = 0.25;
+        this.controls.screenSpacePanning = false;
+        this.controls.minDistance = 700;
+        // this.controls.zoom = 1000;
+        this.controls.maxDistance = 2000;
+        this.controls.maxPolarAngle = Math.PI / 2;
+        this.controls.target = new THREE.Vector3(0, 200, 0);
+        // this.controls.rotation = 100;
+    }
+    setupScene() {
+        // Create a new scene
+        this.scene = new THREE.Scene();
+        // this.scene.background = new THREE.Color(0x080808);
+        // this.scene.fog	= new THREE.FogExp2( 0x000000, 0.1 );
+        this.previewService.scene = this.scene;
+        // Add a little bit of ambient light
+        const ambient = new THREE.AmbientLight(0xffffff, 1.8);
+        this.scene.add(ambient);
+        // Create the stage dimensions
+        this.previewService.updateStage();
+        const lights = [];
+        lights[0] = new THREE.PointLight(0xffffff, 2, 0, 0.1);
+        lights[1] = new THREE.PointLight(0xffffff, 2, 0, 0.1);
+        lights[2] = new THREE.PointLight(0xffffff, 2, 0, 0.1);
+        lights[0].position.set(0, 2000, 0);
+        lights[1].position.set(1000, 2000, 1000);
+        lights[2].position.set(-1000, -2000, -1000);
+        lights[0].castShadow = true;
+        lights[1].castShadow = true;
+        lights[2].castShadow = true;
+        this.scene.add(lights[0]);
+        this.scene.add(lights[1]);
+        this.scene.add(lights[2]);
+        this.previewService.updateFixtureSetup();
+    }
+    ngAfterViewInit() {
+        this.setupRenderer();
+        this.setupCamera();
+        this.setupControls();
+        this.setupScene();
+        this.onResize();
+        this.animate(null);
+    }
+    static { this.ɵfac = function PreviewComponent_Factory(t) { return new (t || PreviewComponent)(i0.ɵɵdirectiveInject(i1.FixtureService), i0.ɵɵdirectiveInject(i2.PreviewMeshService), i0.ɵɵdirectiveInject(i3.AnimationService), i0.ɵɵdirectiveInject(i4.PreviewService), i0.ɵɵdirectiveInject(i5.TimelineService), i0.ɵɵdirectiveInject(i6.ProjectService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PreviewComponent, selectors: [["lib-app-preview"]], viewQuery: function PreviewComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.canvasRef = _t.first);
+        } }, hostBindings: function PreviewComponent_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("resize", function PreviewComponent_resize_HostBindingHandler() { return ctx.onResize(); }, false, i0.ɵɵresolveWindow);
+        } }, decls: 2, vars: 0, consts: [["canvas", ""], [1, "h-100", 2, "overflow", "hidden"]], template: function PreviewComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "div", 1, 0);
+        } } }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PreviewComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-app-preview', template: "<div class=\"h-100\" #canvas style=\"overflow: hidden\"></div>\n" }]
+    }], () => [{ type: i1.FixtureService }, { type: i2.PreviewMeshService }, { type: i3.AnimationService }, { type: i4.PreviewService }, { type: i5.TimelineService }, { type: i6.ProjectService }], { canvasRef: [{
+            type: ViewChild,
+            args: ['canvas']
+        }], onResize: [{
+            type: HostListener,
+            args: ['window:resize']
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PreviewComponent, { className: "PreviewComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preview.component.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/preview/preview.component.ts","../../../../../projects/designer/src/lib/preview/preview.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ElementRef, HostListener, ViewChild } from '@angular/core';\nimport * as THREE from 'three';\nimport { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';\nimport { FixtureCategory } from '../models/fixture-profile';\nimport { FixtureService } from '../services/fixture.service';\nimport { PreviewMeshService } from '../services/preview-mesh.service';\nimport { PreviewService } from '../services/preview.service';\nimport { ProjectService } from '../services/project.service';\nimport { TimelineService } from '../services/timeline.service';\nimport { Positioning } from './../models/fixture';\nimport { AnimationService } from './../services/animation.service';\nimport { ColorChanger3d } from './models/color-changer-3d';\nimport { Fixture3d } from './models/fixture-3d';\nimport { MovingHead3d } from './models/moving-head-3d';\n\n@Component({\n  selector: 'lib-app-preview',\n  templateUrl: './preview.component.html',\n  styleUrls: ['./preview.component.css'],\n})\nexport class PreviewComponent implements AfterViewInit {\n  private renderer: THREE.WebGLRenderer;\n  private scene: THREE.Scene;\n  private camera: THREE.PerspectiveCamera;\n  public controls: OrbitControls;\n\n  private fixtures3d: Fixture3d[] = [];\n\n  @ViewChild('canvas')\n  private canvasRef: ElementRef;\n\n  constructor(\n    private fixtureService: FixtureService,\n    private previewMeshService: PreviewMeshService,\n    private animationService: AnimationService,\n    private previewService: PreviewService,\n    private timelineService: TimelineService,\n    private projectService: ProjectService\n  ) {\n    this.previewService.doUpdateFixtureSetup.subscribe(() => {\n      this.syncFixtures();\n    });\n    this.syncFixtures();\n  }\n\n  // synchronize the 3d-fixtures to the project fixtures\n  private syncFixtures() {\n    if (!this.previewService.scene) {\n      return;\n    }\n\n    // remove all fixtures\n    for (const fixture3d of this.fixtures3d) {\n      fixture3d.destroy();\n    }\n    this.fixtures3d = [];\n\n    // add all fixtures from the project\n    for (const fixture of this.fixtureService.cachedFixtures) {\n      switch (fixture.profile.categories[0]) {\n        case FixtureCategory['Moving Head']:\n          this.fixtures3d.push(new MovingHead3d(this.fixtureService, this.previewMeshService, fixture, this.scene));\n          break;\n        case FixtureCategory['Color Changer']:\n          this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));\n          break;\n        case FixtureCategory['Blinder']:\n          this.fixtures3d.push(new ColorChanger3d(this.fixtureService, this.previewMeshService, fixture, this.scene));\n          break;\n      }\n    }\n  }\n\n  private get canvas(): HTMLCanvasElement {\n    return this.canvasRef.nativeElement;\n  }\n\n  private render() {\n    this.renderer.render(this.scene, this.camera);\n  }\n\n  private updateStagePosition(\n    positioning: Positioning,\n    xMin: number,\n    xMax: number,\n    yMin: number,\n    yMax: number,\n    zMin: number,\n    zMax: number\n  ) {\n    let positionCount = 0; // Number of fixtures in the same position\n    let positionIndex = 1;\n\n    this.projectService.project.presetFixtures.forEach((element, index) => {\n      const fixture = this.fixtureService.getFixtureByUuid(element.fixtureUuid);\n      if (fixture.positioning === positioning) {\n        positionCount++;\n      }\n    });\n\n    this.projectService.project.presetFixtures.forEach((element, index) => {\n      const fixture = this.fixtureService.getFixtureByUuid(element.fixtureUuid);\n      if (fixture.positioning === positioning) {\n        fixture.positionX = xMin + ((xMax - xMin) / (positionCount + 1)) * positionIndex;\n        fixture.positionY = yMin + ((yMax - yMin) / (positionCount + 1)) * positionIndex;\n        fixture.positionZ = zMin + ((zMax - zMin) / (positionCount + 1)) * positionIndex;\n\n        positionIndex++;\n      }\n    });\n  }\n\n  private animate(timeMillis: number) {\n    if (this.timelineService.playState === 'playing') {\n      // Overwrite the current time with the playing time, if we're in playback mode\n      timeMillis = this.timelineService.waveSurfer.getCurrentTime() * 1000;\n    }\n\n    this.animationService.timeMillis = timeMillis;\n\n    // Update the controls\n    if (this.controls) {\n      this.controls.update();\n    }\n\n    // Update the positions\n    this.updateStagePosition(\n      Positioning.topFront,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageDepthCm / 2 - 70,\n      this.projectService.project.stageDepthCm / 2 - 70\n    );\n    this.updateStagePosition(\n      Positioning.bottomFront,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageDepthCm / 2 - 70,\n      this.projectService.project.stageDepthCm / 2 - 70\n    );\n    this.updateStagePosition(\n      Positioning.topBack,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageHeightCm + this.projectService.project.stageFloorHeightCm,\n      -this.projectService.project.stageDepthCm / 2 + 70,\n      -this.projectService.project.stageDepthCm / 2 + 70\n    );\n    this.updateStagePosition(\n      Positioning.bottomBack,\n      -this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageWidthCm / 2,\n      this.projectService.project.stageFloorHeightCm,\n      this.projectService.project.stageFloorHeightCm,\n      -this.projectService.project.stageDepthCm / 2 + 70,\n      -this.projectService.project.stageDepthCm / 2 + 70\n    );\n\n    // Update all fixtures and apply the preview properties, if available\n    // TODO Update the fixtures only e.g. 40 times per second according to the \"real\" refresh rate of the DMX interface?\n    const presets = this.previewService.getPresets(timeMillis);\n\n    const calculatedFixtures = this.previewService.getChannelValues(timeMillis, presets);\n\n    for (const fixture3d of this.fixtures3d) {\n      // Update the fixture properties\n      fixture3d.updatePreview(calculatedFixtures.get(fixture3d.fixture) || [], this.projectService.project.masterDimmerValue);\n\n      // Select the fixture, if required\n      if (this.fixtureService.settingsSelection) {\n        fixture3d.isSelected = this.fixtureService.settingsFixtureIsSelected(fixture3d.fixture.fixture);\n      } else {\n        fixture3d.isSelected = this.previewService.fixtureIsSelected(fixture3d.fixture.fixture.uuid, fixture3d.fixture.pixelKey, presets);\n      }\n    }\n\n    // TODO enable for monitoring the DMX universes\n    this.previewService.setUniverseValues(calculatedFixtures, this.projectService.project.masterDimmerValue);\n\n    // Render the scene\n    this.render();\n\n    requestAnimationFrame(this.animate.bind(this));\n  }\n\n  private getAspectRatio(): number {\n    const height = this.canvas.clientHeight;\n\n    if (height === 0) {\n      return 0;\n    }\n\n    return this.canvas.clientWidth / this.canvas.clientHeight;\n  }\n\n  @HostListener('window:resize')\n  public onResize() {\n    this.camera.aspect = this.getAspectRatio();\n    this.camera.updateProjectionMatrix();\n    this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);\n  }\n\n  private setupRenderer() {\n    this.renderer = new THREE.WebGLRenderer({ antialias: true });\n    this.canvas.appendChild(this.renderer.domElement);\n    this.renderer.setPixelRatio(devicePixelRatio);\n    this.renderer.setSize(this.canvas.clientWidth, this.canvas.clientHeight);\n    // this.renderer.shadowMap.enabled = true;\n    // this.renderer.gammaInput = true;\n    // this.renderer.gammaOutput = true;\n  }\n\n  private setupCamera() {\n    this.camera = new THREE.PerspectiveCamera(35, window.innerWidth / window.innerHeight, 1, 10000);\n    this.camera.position.set(-600, 80, 700);\n  }\n\n  private setupControls() {\n    this.controls = new OrbitControls(this.camera, this.renderer.domElement);\n    this.controls.enableKeys = false;\n    this.controls.rotateSpeed = 0.05;\n    this.controls.zoomSpeed = 1.2;\n    this.controls.enableDamping = true;\n    this.controls.dampingFactor = 0.25;\n    this.controls.screenSpacePanning = false;\n    this.controls.minDistance = 700;\n    // this.controls.zoom = 1000;\n    this.controls.maxDistance = 2000;\n    this.controls.maxPolarAngle = Math.PI / 2;\n    this.controls.target = new THREE.Vector3(0, 200, 0);\n    // this.controls.rotation = 100;\n  }\n\n  private setupScene() {\n    // Create a new scene\n    this.scene = new THREE.Scene();\n    // this.scene.background = new THREE.Color(0x080808);\n    // this.scene.fog\t= new THREE.FogExp2( 0x000000, 0.1 );\n\n    this.previewService.scene = this.scene;\n\n    // Add a little bit of ambient light\n    const ambient = new THREE.AmbientLight(0xffffff, 1.8);\n    this.scene.add(ambient);\n\n    // Create the stage dimensions\n    this.previewService.updateStage();\n\n    const lights = [];\n    lights[0] = new THREE.PointLight(0xffffff, 2, 0, 0.1);\n    lights[1] = new THREE.PointLight(0xffffff, 2, 0, 0.1);\n    lights[2] = new THREE.PointLight(0xffffff, 2, 0, 0.1);\n\n    lights[0].position.set(0, 2000, 0);\n    lights[1].position.set(1000, 2000, 1000);\n    lights[2].position.set(-1000, -2000, -1000);\n\n    lights[0].castShadow = true;\n    lights[1].castShadow = true;\n    lights[2].castShadow = true;\n\n    this.scene.add(lights[0]);\n    this.scene.add(lights[1]);\n    this.scene.add(lights[2]);\n\n    this.previewService.updateFixtureSetup();\n  }\n\n  ngAfterViewInit(): void {\n    this.setupRenderer();\n    this.setupCamera();\n    this.setupControls();\n    this.setupScene();\n\n    this.onResize();\n    this.animate(null);\n  }\n}\n","<div class=\"h-100\" #canvas style=\"overflow: hidden\"></div>\n"]}

package/esm2022/lib/project/project-browser/project-browser.component.mjs

@@ -0,0 +1,143 @@
+import { Component } from '@angular/core';
+import { BsModalRef } from 'ngx-bootstrap/modal';
+import { map } from 'rxjs/operators';
+import { ConfigService } from '../../services/config.service';
+import { ProjectLoadService } from '../../services/project-load.service';
+import { ProjectService } from '../../services/project.service';
+import { UserService } from '../../services/user.service';
+import { WarningDialogService } from '../../services/warning-dialog.service';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/modal";
+import * as i2 from "../../services/project.service";
+import * as i3 from "../../services/project-load.service";
+import * as i4 from "../../services/user.service";
+import * as i5 from "../../services/warning-dialog.service";
+import * as i6 from "../../services/config.service";
+import * as i7 from "@angular/common";
+import * as i8 from "@ngx-translate/core";
+import * as i9 from "../../array-sort-pipe";
+function ProjectBrowserComponent_div_8_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 10)(1, "p", 11);
+    i0.ɵɵelement(2, "i", 12);
+    i0.ɵɵelementEnd()();
+} }
+function ProjectBrowserComponent_div_9_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 10)(1, "p", 11);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 1, "designer.project.browser-empty"), " ");
+} }
+function ProjectBrowserComponent_div_10_div_1_Template(rf, ctx) { if (rf & 1) {
+    const _r1 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 15)(1, "div", 16)(2, "div", 17)(3, "a", 18);
+    i0.ɵɵlistener("click", function ProjectBrowserComponent_div_10_div_1_Template_a_click_3_listener() { const project_r2 = i0.ɵɵrestoreView(_r1).$implicit; const ctx_r2 = i0.ɵɵnextContext(2); ctx_r2.openProject(project_r2); return i0.ɵɵresetView(false); });
+    i0.ɵɵelementStart(4, "p", 19);
+    i0.ɵɵtext(5);
+    i0.ɵɵelementEnd()()();
+    i0.ɵɵelementStart(6, "div", 20)(7, "div", 21);
+    i0.ɵɵlistener("click", function ProjectBrowserComponent_div_10_div_1_Template_div_click_7_listener() { const project_r2 = i0.ɵɵrestoreView(_r1).$implicit; const ctx_r2 = i0.ɵɵnextContext(2); ctx_r2.deleteProject(project_r2); return i0.ɵɵresetView(false); });
+    i0.ɵɵelement(8, "i", 22);
+    i0.ɵɵelementEnd()()()();
+} if (rf & 2) {
+    const project_r2 = ctx.$implicit;
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(project_r2.name);
+} }
+function ProjectBrowserComponent_div_10_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 13);
+    i0.ɵɵtemplate(1, ProjectBrowserComponent_div_10_div_1_Template, 9, 1, "div", 14);
+    i0.ɵɵpipe(2, "sort");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind2(2, 1, ctx_r2.projects, "name"));
+} }
+export class ProjectBrowserComponent {
+    constructor(bsModalRef, projectService, projectLoadService, userService, warningDialogService, configService) {
+        this.bsModalRef = bsModalRef;
+        this.projectService = projectService;
+        this.projectLoadService = projectLoadService;
+        this.userService = userService;
+        this.warningDialogService = warningDialogService;
+        this.configService = configService;
+        this.projects = [];
+        this.loading = true;
+        this.loadProjects();
+    }
+    loadProjects() {
+        this.projectService.getAllProjects().subscribe((projects) => {
+            this.projects = projects;
+            this.loading = false;
+        });
+    }
+    ngOnInit() { }
+    cancel() {
+        this.bsModalRef.hide();
+    }
+    openProject(project) {
+        this.bsModalRef.hide();
+        this.projectLoadService.load(project.id, project.name).subscribe(() => {
+            this.userService.setAutoLoadProject(project);
+        });
+    }
+    deleteProject(project) {
+        this.warningDialogService
+            .show('designer.project.delete-warning')
+            .pipe(map((result) => {
+            if (result) {
+                this.projectService.deleteProject(project).subscribe((projects) => {
+                    this.loadProjects();
+                });
+            }
+        }))
+            .subscribe();
+    }
+    static { this.ɵfac = function ProjectBrowserComponent_Factory(t) { return new (t || ProjectBrowserComponent)(i0.ɵɵdirectiveInject(i1.BsModalRef), i0.ɵɵdirectiveInject(i2.ProjectService), i0.ɵɵdirectiveInject(i3.ProjectLoadService), i0.ɵɵdirectiveInject(i4.UserService), i0.ɵɵdirectiveInject(i5.WarningDialogService), i0.ɵɵdirectiveInject(i6.ConfigService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ProjectBrowserComponent, selectors: [["lib-project-browser"]], decls: 18, vars: 12, consts: [[1, "modal-header"], [1, "modal-title", "pull-left"], ["type", "button", "aria-label", "Close", 1, "close", "pull-right", 3, "click"], ["aria-hidden", "true"], [1, "modal-body", "p-0"], ["class", "m-2 d-flex w-100", 4, "ngIf"], ["class", "list-group list-group-flush", "style", "max-height: 500px; overflow-y: scroll", 4, "ngIf"], [1, "modal-footer"], ["href", "#", "role", "button", 1, "mr-3", "my-auto", 3, "click"], ["type", "button", 1, "btn", "btn-primary", 3, "click"], [1, "m-2", "d-flex", "w-100"], [1, "w-100", 2, "text-align", "center"], [1, "fa", "fa-spinner", "fa-pulse", "fa-fw"], [1, "list-group", "list-group-flush", 2, "max-height", "500px", "overflow-y", "scroll"], ["class", "list-group-item", 4, "ngFor", "ngForOf"], [1, "list-group-item"], [1, "row"], [1, "col-auto", "my-auto", "flex-grow"], ["href", "#", 3, "click"], [1, "mb-0", "w-100"], [1, "my-auto"], [1, "col-auto", "my-auto", "pl-0", "text-danger", "float-right", 2, "cursor", "pointer", 3, "click"], ["aria-hidden", "true", 1, "fa", "fa-trash-o"]], template: function ProjectBrowserComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "h4", 1);
+            i0.ɵɵtext(2);
+            i0.ɵɵpipe(3, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(4, "button", 2);
+            i0.ɵɵlistener("click", function ProjectBrowserComponent_Template_button_click_4_listener() { ctx.cancel(); return false; });
+            i0.ɵɵelementStart(5, "span", 3);
+            i0.ɵɵtext(6, "\u00D7");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(7, "div", 4);
+            i0.ɵɵtemplate(8, ProjectBrowserComponent_div_8_Template, 3, 0, "div", 5)(9, ProjectBrowserComponent_div_9_Template, 4, 3, "div", 5)(10, ProjectBrowserComponent_div_10_Template, 3, 4, "div", 6);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(11, "div", 7)(12, "a", 8);
+            i0.ɵɵlistener("click", function ProjectBrowserComponent_Template_a_click_12_listener() { ctx.cancel(); return false; });
+            i0.ɵɵtext(13);
+            i0.ɵɵpipe(14, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(15, "button", 9);
+            i0.ɵɵlistener("click", function ProjectBrowserComponent_Template_button_click_15_listener() { ctx.cancel(); return false; });
+            i0.ɵɵtext(16);
+            i0.ɵɵpipe(17, "translate");
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(2);
+            i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 6, "designer.project.browser-title"));
+            i0.ɵɵadvance(6);
+            i0.ɵɵproperty("ngIf", ctx.loading);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", ctx.projects.length == 0 && !ctx.loading);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", !ctx.loading);
+            i0.ɵɵadvance(3);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(14, 8, "designer.misc.cancel"), " ");
+            i0.ɵɵadvance(3);
+            i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(17, 10, "designer.misc.ok"));
+        } }, dependencies: [i7.NgForOf, i7.NgIf, i8.TranslatePipe, i9.ArraySortPipe] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProjectBrowserComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-project-browser', template: "<div class=\"modal-header\">\n  <h4 class=\"modal-title pull-left\">{{ 'designer.project.browser-title' | translate }}</h4>\n  <button type=\"button\" class=\"close pull-right\" aria-label=\"Close\" (click)=\"cancel(); (false)\">\n    <span aria-hidden=\"true\">&times;</span>\n  </button>\n</div>\n<div class=\"modal-body p-0\">\n  <div *ngIf=\"loading\" class=\"m-2 d-flex w-100\">\n    <p class=\"w-100\" style=\"text-align: center\"><i class=\"fa fa-spinner fa-pulse fa-fw\"></i></p>\n  </div>\n  <div *ngIf=\"projects.length == 0 && !loading\" class=\"m-2 d-flex w-100\">\n    <p class=\"w-100\" style=\"text-align: center\">\n      {{ 'designer.project.browser-empty' | translate }}\n    </p>\n  </div>\n  <div *ngIf=\"!loading\" class=\"list-group list-group-flush\" style=\"max-height: 500px; overflow-y: scroll\">\n    <div class=\"list-group-item\" *ngFor=\"let project of projects | sort: 'name'\">\n      <div class=\"row\">\n        <div class=\"col-auto my-auto flex-grow\">\n          <a href=\"#\" (click)=\"openProject(project); (false)\">\n            <p class=\"mb-0 w-100\">{{ project.name }}</p>\n          </a>\n        </div>\n        <div class=\"my-auto\">\n          <div class=\"col-auto my-auto pl-0 text-danger float-right\" style=\"cursor: pointer\" (click)=\"deleteProject(project); (false)\">\n            <i class=\"fa fa-trash-o\" aria-hidden=\"true\"></i>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n<div class=\"modal-footer\">\n  <a class=\"mr-3 my-auto\" href=\"#\" role=\"button\" (click)=\"cancel(); (false)\">\n    {{ 'designer.misc.cancel' | translate }}\n  </a>\n  <button (click)=\"cancel(); (false)\" type=\"button\" class=\"btn btn-primary\">{{ 'designer.misc.ok' | translate }}</button>\n</div>\n" }]
+    }], () => [{ type: i1.BsModalRef }, { type: i2.ProjectService }, { type: i3.ProjectLoadService }, { type: i4.UserService }, { type: i5.WarningDialogService }, { type: i6.ConfigService }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ProjectBrowserComponent, { className: "ProjectBrowserComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-browser.component.js","sourceRoot":"","sources":["../../../../../../projects/designer/src/lib/project/project-browser/project-browser.component.ts","../../../../../../projects/designer/src/lib/project/project-browser/project-browser.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\nimport { BsModalRef } from 'ngx-bootstrap/modal';\nimport { map } from 'rxjs/operators';\nimport { Project } from '../../models/project';\nimport { ConfigService } from '../../services/config.service';\nimport { ProjectLoadService } from '../../services/project-load.service';\nimport { ProjectService } from '../../services/project.service';\nimport { UserService } from '../../services/user.service';\nimport { WarningDialogService } from '../../services/warning-dialog.service';\n\n@Component({\n  selector: 'lib-project-browser',\n  templateUrl: './project-browser.component.html',\n  styleUrls: ['./project-browser.component.css'],\n})\nexport class ProjectBrowserComponent implements OnInit {\n  projects: Project[] = [];\n  loading = true;\n\n  constructor(\n    private bsModalRef: BsModalRef,\n    private projectService: ProjectService,\n    private projectLoadService: ProjectLoadService,\n    private userService: UserService,\n    private warningDialogService: WarningDialogService,\n    private configService: ConfigService\n  ) {\n    this.loadProjects();\n  }\n\n  private loadProjects() {\n    this.projectService.getAllProjects().subscribe((projects) => {\n      this.projects = projects;\n      this.loading = false;\n    });\n  }\n\n  ngOnInit() {}\n\n  cancel() {\n    this.bsModalRef.hide();\n  }\n\n  openProject(project: Project) {\n    this.bsModalRef.hide();\n    this.projectLoadService.load(project.id, project.name).subscribe(() => {\n      this.userService.setAutoLoadProject(project);\n    });\n  }\n\n  deleteProject(project: Project) {\n    this.warningDialogService\n      .show('designer.project.delete-warning')\n      .pipe(\n        map((result) => {\n          if (result) {\n            this.projectService.deleteProject(project).subscribe((projects) => {\n              this.loadProjects();\n            });\n          }\n        })\n      )\n      .subscribe();\n  }\n}\n","<div class=\"modal-header\">\n  <h4 class=\"modal-title pull-left\">{{ 'designer.project.browser-title' | translate }}</h4>\n  <button type=\"button\" class=\"close pull-right\" aria-label=\"Close\" (click)=\"cancel(); (false)\">\n    <span aria-hidden=\"true\">&times;</span>\n  </button>\n</div>\n<div class=\"modal-body p-0\">\n  <div *ngIf=\"loading\" class=\"m-2 d-flex w-100\">\n    <p class=\"w-100\" style=\"text-align: center\"><i class=\"fa fa-spinner fa-pulse fa-fw\"></i></p>\n  </div>\n  <div *ngIf=\"projects.length == 0 && !loading\" class=\"m-2 d-flex w-100\">\n    <p class=\"w-100\" style=\"text-align: center\">\n      {{ 'designer.project.browser-empty' | translate }}\n    </p>\n  </div>\n  <div *ngIf=\"!loading\" class=\"list-group list-group-flush\" style=\"max-height: 500px; overflow-y: scroll\">\n    <div class=\"list-group-item\" *ngFor=\"let project of projects | sort: 'name'\">\n      <div class=\"row\">\n        <div class=\"col-auto my-auto flex-grow\">\n          <a href=\"#\" (click)=\"openProject(project); (false)\">\n            <p class=\"mb-0 w-100\">{{ project.name }}</p>\n          </a>\n        </div>\n        <div class=\"my-auto\">\n          <div class=\"col-auto my-auto pl-0 text-danger float-right\" style=\"cursor: pointer\" (click)=\"deleteProject(project); (false)\">\n            <i class=\"fa fa-trash-o\" aria-hidden=\"true\"></i>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n<div class=\"modal-footer\">\n  <a class=\"mr-3 my-auto\" href=\"#\" role=\"button\" (click)=\"cancel(); (false)\">\n    {{ 'designer.misc.cancel' | translate }}\n  </a>\n  <button (click)=\"cancel(); (false)\" type=\"button\" class=\"btn btn-primary\">{{ 'designer.misc.ok' | translate }}</button>\n</div>\n"]}

package/esm2022/lib/project/project-import/project-import.component.mjs

@@ -0,0 +1,107 @@
+import { Component, HostListener } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BsModalRef } from 'ngx-bootstrap/modal';
+import { ToastrService } from 'ngx-toastr';
+import { map } from 'rxjs/operators';
+import { ProjectLoadService } from '../../services/project-load.service';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/modal";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "ngx-toastr";
+import * as i4 from "../../services/project-load.service";
+import * as i5 from "ngx-dropzone-wrapper";
+export class ProjectImportComponent {
+    constructor(bsModalRef, translateService, toastrService, projectLoadService) {
+        this.bsModalRef = bsModalRef;
+        this.translateService = translateService;
+        this.toastrService = toastrService;
+        this.projectLoadService = projectLoadService;
+    }
+    ngOnInit() {
+        this.dropzoneConfig = {
+            url: 'dummy',
+            addRemoveLinks: false,
+            maxFilesize: 10 /* 10 MB */,
+            acceptedFiles: '.rsd',
+            timeout: 0,
+            accept: (file, done) => {
+                const reader = new FileReader();
+                reader.addEventListener('loadend', (event) => {
+                    this.projectLoadService.import(event.target.result);
+                    done('noerr');
+                    this.bsModalRef.hide();
+                });
+                reader.readAsText(file);
+            },
+            previewTemplate: `
+      <div style="display: none;">
+        <!-- No preview -->
+      </div>
+      `,
+        };
+        this.translateService
+            .get('designer.misc.dropzone-message')
+            .pipe(map((result) => {
+            this.uploadMessage = '<h3 class="mb-0"><i class="fa fa-cloud-upload"></i></h3>' + result;
+        }))
+            .subscribe();
+    }
+    onUploadError(args) {
+        if (args[1] === 'noerr') {
+            // this error is set in the accept event listener -> everything OK
+            return;
+        }
+        const msg = 'designer.misc.toast-upload-error';
+        const title = 'designer.misc.toast-upload-error-title';
+        this.translateService.get([msg, title]).subscribe((result) => {
+            this.toastrService.error(result[msg] + args[1], result[title], { timeOut: 0, extendedTimeOut: 0, enableHtml: true });
+        });
+    }
+    ok() {
+        this.bsModalRef.hide();
+    }
+    cancel() {
+        this.bsModalRef.hide();
+    }
+    handleKeyboardEvent(event) {
+        this.ok();
+    }
+    static { this.ɵfac = function ProjectImportComponent_Factory(t) { return new (t || ProjectImportComponent)(i0.ɵɵdirectiveInject(i1.BsModalRef), i0.ɵɵdirectiveInject(i2.TranslateService), i0.ɵɵdirectiveInject(i3.ToastrService), i0.ɵɵdirectiveInject(i4.ProjectLoadService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ProjectImportComponent, selectors: [["lib-project-import"]], hostBindings: function ProjectImportComponent_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("keydown.enter", function ProjectImportComponent_keydown_enter_HostBindingHandler($event) { return ctx.handleKeyboardEvent($event); }, false, i0.ɵɵresolveDocument);
+        } }, decls: 13, vars: 9, consts: [[1, "modal-header"], [1, "modal-title", "pull-left"], ["type", "button", "aria-label", "Close", 1, "close", "pull-right", 3, "click"], ["aria-hidden", "true"], [1, "modal-body"], [3, "error", "config", "useDropzoneClass", "message"], [1, "modal-footer"], ["type", "button", 1, "btn", "btn-primary", 3, "click"]], template: function ProjectImportComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "h4", 1);
+            i0.ɵɵtext(2);
+            i0.ɵɵpipe(3, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(4, "button", 2);
+            i0.ɵɵlistener("click", function ProjectImportComponent_Template_button_click_4_listener() { return ctx.bsModalRef.hide(); });
+            i0.ɵɵelementStart(5, "span", 3);
+            i0.ɵɵtext(6, "\u00D7");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(7, "div", 4)(8, "dropzone", 5);
+            i0.ɵɵlistener("error", function ProjectImportComponent_Template_dropzone_error_8_listener($event) { return ctx.onUploadError($event); });
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelementStart(9, "div", 6)(10, "button", 7);
+            i0.ɵɵlistener("click", function ProjectImportComponent_Template_button_click_10_listener() { return ctx.ok(); });
+            i0.ɵɵtext(11);
+            i0.ɵɵpipe(12, "translate");
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(2);
+            i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 5, "designer.project.import-title"));
+            i0.ɵɵadvance(6);
+            i0.ɵɵproperty("config", ctx.dropzoneConfig)("useDropzoneClass", "false")("message", ctx.uploadMessage);
+            i0.ɵɵadvance(3);
+            i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(12, 7, "designer.misc.ok"));
+        } }, dependencies: [i5.DropzoneComponent, i2.TranslatePipe] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProjectImportComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-project-import', template: "<div class=\"modal-header\">\n  <h4 class=\"modal-title pull-left\">{{ 'designer.project.import-title' | translate }}</h4>\n  <button type=\"button\" class=\"close pull-right\" aria-label=\"Close\" (click)=\"bsModalRef.hide()\">\n    <span aria-hidden=\"true\">&times;</span>\n  </button>\n</div>\n<div class=\"modal-body\">\n  <!-- Dropzone -->\n  <dropzone [config]=\"dropzoneConfig\" [useDropzoneClass]=\"'false'\" [message]=\"uploadMessage\" (error)=\"onUploadError($event)\"></dropzone>\n</div>\n<div class=\"modal-footer\">\n  <button type=\"button\" class=\"btn btn-primary\" (click)=\"ok()\">{{ 'designer.misc.ok' | translate }}</button>\n</div>\n" }]
+    }], () => [{ type: i1.BsModalRef }, { type: i2.TranslateService }, { type: i3.ToastrService }, { type: i4.ProjectLoadService }], { handleKeyboardEvent: [{
+            type: HostListener,
+            args: ['document:keydown.enter', ['$event']]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ProjectImportComponent, { className: "ProjectImportComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,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