@rocketshow/designer 1.32.0 → 1.35.0

package/esm2022/lib/services/project-load.service.mjs

@@ -0,0 +1,209 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { BsModalService } from 'ngx-bootstrap/modal';
+import { finalize, map } from 'rxjs/operators';
+import { Preset } from '../models/preset';
+import { Project } from '../models/project';
+import { WaitDialogComponent } from '../wait-dialog/wait-dialog.component';
+import { FixtureService } from './fixture.service';
+import { PresetService } from './preset.service';
+import { PreviewService } from './preview.service';
+import { ProjectService } from './project.service';
+import { SceneService } from './scene.service';
+import { TimelineService } from './timeline.service';
+import { UuidService } from './uuid.service';
+import { PresetFixture } from '../models/preset-fixture';
+import { WarningDialogService } from './warning-dialog.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./project.service";
+import * as i2 from "./preview.service";
+import * as i3 from "./fixture.service";
+import * as i4 from "./preset.service";
+import * as i5 from "./scene.service";
+import * as i6 from "ngx-bootstrap/modal";
+import * as i7 from "./uuid.service";
+import * as i8 from "./timeline.service";
+import * as i9 from "@angular/router";
+import * as i10 from "./warning-dialog.service";
+export class ProjectLoadService {
+    constructor(projectService, previewService, fixtureService, presetService, sceneService, modalService, uuidService, timelineService, router, activatedRoute, warningDialogService) {
+        this.projectService = projectService;
+        this.previewService = previewService;
+        this.fixtureService = fixtureService;
+        this.presetService = presetService;
+        this.sceneService = sceneService;
+        this.modalService = modalService;
+        this.uuidService = uuidService;
+        this.timelineService = timelineService;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.warningDialogService = warningDialogService;
+    }
+    migrateToVersion2() {
+        for (let fixture of this.projectService.project.fixtures) {
+            const pixelKeys = this.fixtureService.fixtureGetUniquePixelKeys(fixture);
+            if (pixelKeys.length > 0) {
+                for (let pixelKey of pixelKeys) {
+                    const projectFixture = new PresetFixture();
+                    projectFixture.fixtureUuid = fixture.uuid;
+                    projectFixture.pixelKey = pixelKey;
+                    this.projectService.project.presetFixtures.push(projectFixture);
+                }
+            }
+            else {
+                const projectFixture = new PresetFixture();
+                projectFixture.fixtureUuid = fixture.uuid;
+                this.projectService.project.presetFixtures.push(projectFixture);
+            }
+        }
+        for (let preset of this.projectService.project.presets) {
+            for (let fixtureUuid of preset.fixtureUuids) {
+                const fixture = this.fixtureService.getFixtureByUuid(fixtureUuid);
+                const pixelKeys = this.fixtureService.fixtureGetUniquePixelKeys(fixture);
+                if (pixelKeys.length > 0) {
+                    for (let pixelKey of pixelKeys) {
+                        const presetFixture = new PresetFixture();
+                        presetFixture.fixtureUuid = fixtureUuid;
+                        presetFixture.pixelKey = pixelKey;
+                        preset.fixtures.push(presetFixture);
+                    }
+                }
+                else {
+                    const presetFixture = new PresetFixture();
+                    presetFixture.fixtureUuid = fixtureUuid;
+                    preset.fixtures.push(presetFixture);
+                }
+            }
+        }
+        this.projectService.project.version = 2;
+    }
+    migrateFromOldProject() {
+        let migrated = false;
+        if (!this.projectService.project.version) {
+            // Migrate from version 1
+            this.migrateToVersion2();
+            migrated = true;
+        }
+        if (migrated) {
+            this.warningDialogService.show('designer.project.migrated').subscribe();
+        }
+    }
+    afterLoad() {
+        this.migrateFromOldProject();
+        this.fixtureService.updateCachedFixtures();
+        this.presetService.removeDeletedFixtures();
+        this.previewService.updateFixtureSetup();
+        this.presetService.fixtureSelectionChanged.next();
+        this.presetService.autoOpenFirstEffect();
+        this.previewService.updateStage();
+        this.presetService.previewLive();
+        this.sceneService.selectPresetFromSelectedScene();
+    }
+    selectScenesPresetComposition() {
+        this.presetService.selectedPreset = this.presetService.getPresetByUuid(this.projectService.project.selectedPresetUuid);
+        this.sceneService.selectedScenes = [];
+        if (this.projectService.project.selectedSceneUuids) {
+            for (const uuid of this.projectService.project.selectedSceneUuids) {
+                this.sceneService.selectedScenes.push(this.sceneService.getSceneByUuid(uuid));
+            }
+        }
+        this.timelineService.selectedComposition = undefined;
+        this.timelineService.selectedCompositionIndex = undefined;
+        this.timelineService.destroyWaveSurfer();
+        for (let i = 0; i < this.projectService.project.compositions.length; i++) {
+            if (this.projectService.project.compositions[i].uuid === this.projectService.project.selectedCompositionUuid) {
+                this.timelineService.selectCompositionIndex(i);
+                break;
+            }
+        }
+    }
+    load(id, name, shareToken) {
+        const ref = this.modalService.show(WaitDialogComponent, { keyboard: false, ignoreBackdropClick: true });
+        return this.projectService.getProject(id, name, shareToken).pipe(map((project) => {
+            if (project.version > this.projectService.currentProjectVersion) {
+                throw new Error('The project version ' +
+                    project.version +
+                    ' is created with a newer version of the designer. Please update your Rocket Show version to open this project.');
+            }
+            this.projectService.project = project;
+            this.selectScenesPresetComposition();
+            this.afterLoad();
+            const queryParams = {
+                id,
+                token: project.shareToken,
+            };
+            this.router.navigate([], {
+                relativeTo: this.activatedRoute,
+                queryParams,
+                queryParamsHandling: 'merge', // remove to replace all query params by provided
+            });
+        }), finalize(() => {
+            // hide the modal again because of:
+            // https://github.com/valor-software/ngx-bootstrap/issues/3711
+            setTimeout(() => {
+                ref.hide();
+            }, 250);
+            setTimeout(() => {
+                ref.hide();
+            }, 500);
+            setTimeout(() => {
+                ref.hide();
+            }, 1500);
+        }));
+    }
+    new() {
+        // create an empty new project
+        const project = new Project();
+        project.uuid = this.uuidService.getUuid();
+        project.version = this.projectService.currentProjectVersion;
+        this.projectService.project = project;
+        this.projectService.project.shareToken = this.uuidService.getUuid();
+        // Add a default scene and preset
+        const preset = new Preset();
+        preset.uuid = this.uuidService.getUuid();
+        preset.name = 'New Preset';
+        this.projectService.project.presets.push(preset);
+        this.presetService.selectPreset(0);
+        this.sceneService.addScene();
+        this.projectService.project.scenes[0].presetUuids.push(preset.uuid);
+        this.projectService.project.previewPreset = true;
+        this.sceneService.selectedScenes = [this.projectService.project.scenes[0]];
+        this.presetService.selectedPreset = this.projectService.project.presets[0];
+        this.timelineService.selectedComposition = undefined;
+        this.timelineService.selectedCompositionIndex = undefined;
+        this.timelineService.destroyWaveSurfer();
+        this.afterLoad();
+        const queryParams = {
+            id: '',
+            token: '',
+        };
+        this.router.navigate([], {
+            relativeTo: this.activatedRoute,
+            queryParams,
+            queryParamsHandling: 'merge', // remove to replace all query params by provided
+        });
+    }
+    template() {
+        // load the template project with id 1
+        this.load(1, null).subscribe(() => {
+            this.projectService.project.id = undefined;
+        });
+    }
+    import(data) {
+        // import a project from a string
+        const project = new Project(JSON.parse(data));
+        project.id = undefined;
+        this.projectService.project = project;
+        this.selectScenesPresetComposition();
+        this.afterLoad();
+    }
+    static { this.ɵfac = function ProjectLoadService_Factory(t) { return new (t || ProjectLoadService)(i0.ɵɵinject(i1.ProjectService), i0.ɵɵinject(i2.PreviewService), i0.ɵɵinject(i3.FixtureService), i0.ɵɵinject(i4.PresetService), i0.ɵɵinject(i5.SceneService), i0.ɵɵinject(i6.BsModalService), i0.ɵɵinject(i7.UuidService), i0.ɵɵinject(i8.TimelineService), i0.ɵɵinject(i9.Router), i0.ɵɵinject(i9.ActivatedRoute), i0.ɵɵinject(i10.WarningDialogService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProjectLoadService, factory: ProjectLoadService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProjectLoadService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.ProjectService }, { type: i2.PreviewService }, { type: i3.FixtureService }, { type: i4.PresetService }, { type: i5.SceneService }, { type: i6.BsModalService }, { type: i7.UuidService }, { type: i8.TimelineService }, { type: i9.Router }, { type: i9.ActivatedRoute }, { type: i10.WarningDialogService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-load.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/project-load.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ActivatedRoute, Params, Router } from '@angular/router';\nimport { BsModalService } from 'ngx-bootstrap/modal';\nimport { Observable } from 'rxjs';\nimport { finalize, map } from 'rxjs/operators';\nimport { Preset } from '../models/preset';\nimport { Project } from '../models/project';\nimport { WaitDialogComponent } from '../wait-dialog/wait-dialog.component';\nimport { FixtureService } from './fixture.service';\nimport { PresetService } from './preset.service';\nimport { PreviewService } from './preview.service';\nimport { ProjectService } from './project.service';\nimport { SceneService } from './scene.service';\nimport { TimelineService } from './timeline.service';\nimport { UuidService } from './uuid.service';\nimport { PresetFixture } from '../models/preset-fixture';\nimport { WarningDialogService } from './warning-dialog.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProjectLoadService {\n  constructor(\n    private projectService: ProjectService,\n    private previewService: PreviewService,\n    private fixtureService: FixtureService,\n    private presetService: PresetService,\n    private sceneService: SceneService,\n    private modalService: BsModalService,\n    private uuidService: UuidService,\n    private timelineService: TimelineService,\n    private router: Router,\n    private activatedRoute: ActivatedRoute,\n    private warningDialogService: WarningDialogService\n  ) {}\n\n  private migrateToVersion2() {\n    for (let fixture of this.projectService.project.fixtures) {\n      const pixelKeys = this.fixtureService.fixtureGetUniquePixelKeys(fixture);\n      if (pixelKeys.length > 0) {\n        for (let pixelKey of pixelKeys) {\n          const projectFixture = new PresetFixture();\n          projectFixture.fixtureUuid = fixture.uuid;\n          projectFixture.pixelKey = pixelKey;\n          this.projectService.project.presetFixtures.push(projectFixture);\n        }\n      } else {\n        const projectFixture = new PresetFixture();\n        projectFixture.fixtureUuid = fixture.uuid;\n        this.projectService.project.presetFixtures.push(projectFixture);\n      }\n    }\n    for (let preset of this.projectService.project.presets) {\n      for (let fixtureUuid of preset.fixtureUuids) {\n        const fixture = this.fixtureService.getFixtureByUuid(fixtureUuid);\n        const pixelKeys = this.fixtureService.fixtureGetUniquePixelKeys(fixture);\n        if (pixelKeys.length > 0) {\n          for (let pixelKey of pixelKeys) {\n            const presetFixture = new PresetFixture();\n            presetFixture.fixtureUuid = fixtureUuid;\n            presetFixture.pixelKey = pixelKey;\n            preset.fixtures.push(presetFixture);\n          }\n        } else {\n          const presetFixture = new PresetFixture();\n          presetFixture.fixtureUuid = fixtureUuid;\n          preset.fixtures.push(presetFixture);\n        }\n      }\n    }\n    this.projectService.project.version = 2;\n  }\n\n  private migrateFromOldProject() {\n    let migrated = false;\n\n    if (!this.projectService.project.version) {\n      // Migrate from version 1\n      this.migrateToVersion2();\n      migrated = true;\n    }\n\n    if (migrated) {\n      this.warningDialogService.show('designer.project.migrated').subscribe();\n    }\n  }\n\n  private afterLoad() {\n    this.migrateFromOldProject();\n    this.fixtureService.updateCachedFixtures();\n    this.presetService.removeDeletedFixtures();\n    this.previewService.updateFixtureSetup();\n    this.presetService.fixtureSelectionChanged.next();\n    this.presetService.autoOpenFirstEffect();\n    this.previewService.updateStage();\n    this.presetService.previewLive();\n    this.sceneService.selectPresetFromSelectedScene();\n  }\n\n  private selectScenesPresetComposition() {\n    this.presetService.selectedPreset = this.presetService.getPresetByUuid(this.projectService.project.selectedPresetUuid);\n    this.sceneService.selectedScenes = [];\n    if (this.projectService.project.selectedSceneUuids) {\n      for (const uuid of this.projectService.project.selectedSceneUuids) {\n        this.sceneService.selectedScenes.push(this.sceneService.getSceneByUuid(uuid));\n      }\n    }\n    this.timelineService.selectedComposition = undefined;\n    this.timelineService.selectedCompositionIndex = undefined;\n    this.timelineService.destroyWaveSurfer();\n    for (let i = 0; i < this.projectService.project.compositions.length; i++) {\n      if (this.projectService.project.compositions[i].uuid === this.projectService.project.selectedCompositionUuid) {\n        this.timelineService.selectCompositionIndex(i);\n        break;\n      }\n    }\n  }\n\n  load(id: number, name: string, shareToken?: string): Observable<void> {\n    const ref = this.modalService.show(WaitDialogComponent, { keyboard: false, ignoreBackdropClick: true });\n\n    return this.projectService.getProject(id, name, shareToken).pipe(\n      map((project) => {\n        if (project.version > this.projectService.currentProjectVersion) {\n          throw new Error(\n            'The project version ' +\n              project.version +\n              ' is created with a newer version of the designer. Please update your Rocket Show version to open this project.'\n          );\n        }\n        this.projectService.project = project;\n        this.selectScenesPresetComposition();\n        this.afterLoad();\n\n        const queryParams: Params = {\n          id,\n          token: project.shareToken,\n        };\n        this.router.navigate([], {\n          relativeTo: this.activatedRoute,\n          queryParams,\n          queryParamsHandling: 'merge', // remove to replace all query params by provided\n        });\n      }),\n      finalize(() => {\n        // hide the modal again because of:\n        // https://github.com/valor-software/ngx-bootstrap/issues/3711\n        setTimeout(() => {\n          ref.hide();\n        }, 250);\n        setTimeout(() => {\n          ref.hide();\n        }, 500);\n        setTimeout(() => {\n          ref.hide();\n        }, 1500);\n      })\n    );\n  }\n\n  new() {\n    // create an empty new project\n    const project = new Project();\n    project.uuid = this.uuidService.getUuid();\n    project.version = this.projectService.currentProjectVersion;\n    this.projectService.project = project;\n    this.projectService.project.shareToken = this.uuidService.getUuid();\n\n    // Add a default scene and preset\n    const preset = new Preset();\n    preset.uuid = this.uuidService.getUuid();\n    preset.name = 'New Preset';\n    this.projectService.project.presets.push(preset);\n    this.presetService.selectPreset(0);\n\n    this.sceneService.addScene();\n    this.projectService.project.scenes[0].presetUuids.push(preset.uuid);\n\n    this.projectService.project.previewPreset = true;\n\n    this.sceneService.selectedScenes = [this.projectService.project.scenes[0]];\n    this.presetService.selectedPreset = this.projectService.project.presets[0];\n\n    this.timelineService.selectedComposition = undefined;\n    this.timelineService.selectedCompositionIndex = undefined;\n    this.timelineService.destroyWaveSurfer();\n\n    this.afterLoad();\n\n    const queryParams: Params = {\n      id: '',\n      token: '',\n    };\n    this.router.navigate([], {\n      relativeTo: this.activatedRoute,\n      queryParams,\n      queryParamsHandling: 'merge', // remove to replace all query params by provided\n    });\n  }\n\n  template() {\n    // load the template project with id 1\n    this.load(1, null).subscribe(() => {\n      this.projectService.project.id = undefined;\n    });\n  }\n\n  import(data: string) {\n    // import a project from a string\n    const project = new Project(JSON.parse(data));\n    project.id = undefined;\n    this.projectService.project = project;\n\n    this.selectScenesPresetComposition();\n    this.afterLoad();\n  }\n}\n"]}

package/esm2022/lib/services/project.service.mjs

@@ -0,0 +1,93 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { ToastrService } from 'ngx-toastr';
+import { map } from 'rxjs/operators';
+import { Project } from '../models/project';
+import { UserService } from './user.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./user.service";
+import * as i3 from "@angular/router";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "ngx-toastr";
+export class ProjectService {
+    constructor(http, userService, router, activatedRoute, translateService, toastrService) {
+        this.http = http;
+        this.userService = userService;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.translateService = translateService;
+        this.toastrService = toastrService;
+        // the project-file versions used in this version of the designer (older ones will be migrated, newer ones are not supported)
+        this.currentProjectVersion = 2;
+    }
+    saveApi(project) {
+        return this.http.post('project', JSON.stringify(project), { headers: this.userService.getHeaders() }).pipe(map((response) => {
+            if (response) {
+                project.id = response.id;
+                if (response.shareToken) {
+                    project.shareToken = response.shareToken;
+                }
+                const queryParams = {
+                    id: project.id,
+                    token: project.shareToken,
+                };
+                this.router.navigate([], {
+                    relativeTo: this.activatedRoute,
+                    queryParams,
+                    queryParamsHandling: 'merge', // remove to replace all query params by provided
+                });
+            }
+            return null;
+        }));
+    }
+    save(project) {
+        // tries to save the project and returns, whether it has been saved or not
+        this.saveApi(project).subscribe(() => {
+            const msg = 'designer.project.save-success';
+            const title = 'designer.project.save-success-title';
+            this.translateService.get([msg, title]).subscribe((result) => {
+                this.toastrService.success(result[msg], result[title]);
+            });
+            this.userService.setAutoLoadProject(project);
+        }, (response) => {
+            const msg = 'designer.project.save-error';
+            const title = 'designer.project.save-error-title';
+            const error = response && response.error ? response.error.error : 'unknown';
+            this.translateService.get([msg, title]).subscribe((result) => {
+                this.toastrService.error(result[msg] + ' (' + error + ')', result[title]);
+            });
+        });
+    }
+    getAllProjects() {
+        return this.http.get('projects', { headers: this.userService.getHeaders() }).pipe(map((response) => {
+            const projects = [];
+            for (const project of response) {
+                const projectObject = new Project(project);
+                projects.push(projectObject);
+            }
+            return projects;
+        }));
+    }
+    deleteProject(project) {
+        return this.http.delete('project?id=' + project.id + '&name=' + project.name, { headers: this.userService.getHeaders() });
+    }
+    getProject(id, name, shareToken) {
+        return this.http.get('project?id=' + id + '&name=' + name + '&token=' + shareToken, { headers: this.userService.getHeaders() }).pipe(map((response) => {
+            const project = new Project(response);
+            project.id = id;
+            return project;
+        }));
+    }
+    static { this.ɵfac = function ProjectService_Factory(t) { return new (t || ProjectService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.UserService), i0.ɵɵinject(i3.Router), i0.ɵɵinject(i3.ActivatedRoute), i0.ɵɵinject(i4.TranslateService), i0.ɵɵinject(i5.ToastrService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProjectService, factory: ProjectService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProjectService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.HttpClient }, { type: i2.UserService }, { type: i3.Router }, { type: i3.ActivatedRoute }, { type: i4.TranslateService }, { type: i5.ToastrService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/project.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAU,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;;;;;;;AAK7C,MAAM,OAAO,cAAc;IAOzB,YACU,IAAgB,EAChB,WAAwB,EACxB,MAAc,EACd,cAA8B,EAC9B,gBAAkC,EAClC,aAA4B;QAL5B,SAAI,GAAJ,IAAI,CAAY;QAChB,gBAAW,GAAX,WAAW,CAAa;QACxB,WAAM,GAAN,MAAM,CAAQ;QACd,mBAAc,GAAd,cAAc,CAAgB;QAC9B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,kBAAa,GAAb,aAAa,CAAe;QATtC,6HAA6H;QACtH,0BAAqB,GAAG,CAAC,CAAC;IAS9B,CAAC;IAEI,OAAO,CAAC,OAAgB;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,IAAI,CACxG,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE;YACpB,IAAI,QAAQ,EAAE,CAAC;gBACb,OAAO,CAAC,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC;gBACzB,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;oBACxB,OAAO,CAAC,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;gBAC3C,CAAC;gBACD,MAAM,WAAW,GAAW;oBAC1B,EAAE,EAAE,OAAO,CAAC,EAAE;oBACd,KAAK,EAAE,OAAO,CAAC,UAAU;iBAC1B,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE;oBACvB,UAAU,EAAE,IAAI,CAAC,cAAc;oBAC/B,WAAW;oBACX,mBAAmB,EAAE,OAAO,EAAE,iDAAiD;iBAChF,CAAC,CAAC;YACL,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,OAAgB;QACnB,0EAA0E;QAC1E,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,SAAS,CAC7B,GAAG,EAAE;YACH,MAAM,GAAG,GAAG,+BAA+B,CAAC;YAC5C,MAAM,KAAK,GAAG,qCAAqC,CAAC;YAEpD,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;gBAC3D,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACzD,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAC/C,CAAC,EACD,CAAC,QAAQ,EAAE,EAAE;YACX,MAAM,GAAG,GAAG,6BAA6B,CAAC;YAC1C,MAAM,KAAK,GAAG,mCAAmC,CAAC;YAClD,MAAM,KAAK,GAAG,QAAQ,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;YAE5E,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;gBAC3D,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,GAAG,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5E,CAAC,CAAC,CAAC;QACL,CAAC,CACF,CAAC;IACJ,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,IAAI,CAC/E,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE;YACpB,MAAM,QAAQ,GAAc,EAAE,CAAC;YAC/B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;gBAC/B,MAAM,aAAa,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;gBAC3C,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAC/B,CAAC;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,aAAa,CAAC,OAAgB;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,OAAO,CAAC,EAAE,GAAG,QAAQ,GAAG,OAAO,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAC5H,CAAC;IAED,UAAU,CAAC,EAAU,EAAE,IAAY,EAAE,UAAmB;QACtD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,EAAE,GAAG,QAAQ,GAAG,IAAI,GAAG,SAAS,GAAG,UAAU,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,IAAI,CAClI,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE;YACpB,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC;YACtC,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;YAEhB,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;+EA1FU,cAAc;uEAAd,cAAc,WAAd,cAAc,mBAFb,MAAM;;iFAEP,cAAc;cAH1B,UAAU;eAAC;gBACV,UAAU,EAAE,MAAM;aACnB","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { ActivatedRoute, Params, Router } from '@angular/router';\nimport { TranslateService } from '@ngx-translate/core';\nimport { ToastrService } from 'ngx-toastr';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Project } from '../models/project';\nimport { UserService } from './user.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProjectService {\n  // the current project\n  public project: Project;\n\n  // the project-file versions used in this version of the designer (older ones will be migrated, newer ones are not supported)\n  public currentProjectVersion = 2;\n\n  constructor(\n    private http: HttpClient,\n    private userService: UserService,\n    private router: Router,\n    private activatedRoute: ActivatedRoute,\n    private translateService: TranslateService,\n    private toastrService: ToastrService\n  ) {}\n\n  private saveApi(project: Project): Observable<object> {\n    return this.http.post('project', JSON.stringify(project), { headers: this.userService.getHeaders() }).pipe(\n      map((response: any) => {\n        if (response) {\n          project.id = response.id;\n          if (response.shareToken) {\n            project.shareToken = response.shareToken;\n          }\n          const queryParams: Params = {\n            id: project.id,\n            token: project.shareToken,\n          };\n          this.router.navigate([], {\n            relativeTo: this.activatedRoute,\n            queryParams,\n            queryParamsHandling: 'merge', // remove to replace all query params by provided\n          });\n        }\n        return null;\n      })\n    );\n  }\n\n  save(project: Project) {\n    // tries to save the project and returns, whether it has been saved or not\n    this.saveApi(project).subscribe(\n      () => {\n        const msg = 'designer.project.save-success';\n        const title = 'designer.project.save-success-title';\n\n        this.translateService.get([msg, title]).subscribe((result) => {\n          this.toastrService.success(result[msg], result[title]);\n        });\n\n        this.userService.setAutoLoadProject(project);\n      },\n      (response) => {\n        const msg = 'designer.project.save-error';\n        const title = 'designer.project.save-error-title';\n        const error = response && response.error ? response.error.error : 'unknown';\n\n        this.translateService.get([msg, title]).subscribe((result) => {\n          this.toastrService.error(result[msg] + ' (' + error + ')', result[title]);\n        });\n      }\n    );\n  }\n\n  getAllProjects(): Observable<Project[]> {\n    return this.http.get('projects', { headers: this.userService.getHeaders() }).pipe(\n      map((response: any) => {\n        const projects: Project[] = [];\n        for (const project of response) {\n          const projectObject = new Project(project);\n          projects.push(projectObject);\n        }\n        return projects;\n      })\n    );\n  }\n\n  deleteProject(project: Project): Observable<any> {\n    return this.http.delete('project?id=' + project.id + '&name=' + project.name, { headers: this.userService.getHeaders() });\n  }\n\n  getProject(id: number, name: string, shareToken?: string): Observable<Project> {\n    return this.http.get('project?id=' + id + '&name=' + name + '&token=' + shareToken, { headers: this.userService.getHeaders() }).pipe(\n      map((response: any) => {\n        const project = new Project(response);\n        project.id = id;\n\n        return project;\n      })\n    );\n  }\n}\n"]}

package/esm2022/lib/services/scene.service.mjs

@@ -0,0 +1,164 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Scene } from '../models/scene';
+import { EffectService } from './effect.service';
+import { PresetService } from './preset.service';
+import { ProjectService } from './project.service';
+import { UuidService } from './uuid.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./uuid.service";
+import * as i2 from "./effect.service";
+import * as i3 from "./preset.service";
+import * as i4 from "./project.service";
+export class SceneService {
+    constructor(uuidService, effectService, presetService, projectService) {
+        this.uuidService = uuidService;
+        this.effectService = effectService;
+        this.presetService = presetService;
+        this.projectService = projectService;
+        this.selectedScenes = [];
+        this.sceneColors = ['#945fda', '#61da5f', '#5fc3da', '#dad65f', '#da5f5f', '#246db7'];
+        this.multipleSelection = false;
+        this.sceneDeleted = new Subject();
+        this.sceneSelected = new Subject();
+    }
+    sceneIsSelected(scene) {
+        for (const selectedScene of this.selectedScenes) {
+            if (selectedScene.uuid === scene.uuid) {
+                return true;
+            }
+        }
+        return false;
+    }
+    presetIsSelected(preset) {
+        if (!this.selectedScenes || this.selectedScenes.length !== 1) {
+            return false;
+        }
+        for (const uuid of this.selectedScenes[0].presetUuids) {
+            if (preset.uuid === uuid) {
+                return true;
+            }
+        }
+        return false;
+    }
+    switchSceneSelection(scene) {
+        // Select a scene if not yet selected or unselect it otherwise
+        if (this.sceneIsSelected(scene)) {
+            for (let i = 0; i < this.selectedScenes.length; i++) {
+                if (this.selectedScenes[i].uuid === scene.uuid) {
+                    this.selectedScenes.splice(i, 1);
+                    return;
+                }
+            }
+        }
+        else {
+            this.selectedScenes.push(scene);
+        }
+        this.sceneSelected.next();
+    }
+    selectPresetFromSelectedScene() {
+        // select the first preset of the scene, if no preset of the current scene is already
+        // selected to make sure, the user does not edit a preset which is not even
+        // active in the current scene (and sees no change).
+        let firstPresetUuid;
+        // check, whether a preset of the current scene is already selected and do nothing
+        // in this case
+        for (const scene of this.selectedScenes) {
+            for (const presetUuid of scene.presetUuids) {
+                firstPresetUuid = presetUuid;
+                if (presetUuid === this.presetService.selectedPreset.uuid) {
+                    // a preset of a currently selected scene is already selected -> do nothing
+                    return;
+                }
+            }
+        }
+        if (!firstPresetUuid) {
+            return;
+        }
+        for (let i = 0; i < this.projectService.project.presets.length; i++) {
+            if (this.projectService.project.presets[i].uuid === firstPresetUuid) {
+                this.presetService.selectPreset(i);
+                break;
+            }
+        }
+    }
+    selectScene(index) {
+        this.effectService.selectedEffect = undefined;
+        if (index >= this.projectService.project.scenes.length) {
+            this.selectedScenes = [];
+        }
+        else {
+            if (this.multipleSelection) {
+                this.switchSceneSelection(this.projectService.project.scenes[index]);
+            }
+            else {
+                this.selectedScenes = [];
+                this.selectedScenes.push(this.projectService.project.scenes[index]);
+            }
+        }
+        this.selectPresetFromSelectedScene();
+        // preview the complete scene
+        this.projectService.project.previewPreset = false;
+        this.projectService.project.selectedSceneUuids = [];
+        for (const scene of this.selectedScenes) {
+            this.projectService.project.selectedSceneUuids.push(scene.uuid);
+        }
+        this.presetService.previewSelectionChanged.next();
+        this.presetService.previewLive();
+        this.sceneSelected.next();
+    }
+    addScene(name) {
+        const scene = new Scene();
+        scene.uuid = this.uuidService.getUuid();
+        scene.name = name || 'New Scene';
+        if (this.projectService.project.scenes.length < this.sceneColors.length) {
+            scene.color = this.sceneColors[this.projectService.project.scenes.length];
+        }
+        else {
+            scene.color = '#' + Math.random().toString(16).slice(2, 8).toUpperCase();
+        }
+        // Insert the new scene before the highest currently selected scene
+        let highestSelectedSceneIndex = 0;
+        for (let i = 0; i < this.projectService.project.scenes.length; i++) {
+            if (this.sceneIsSelected(this.projectService.project.scenes[i])) {
+                highestSelectedSceneIndex = i;
+                break;
+            }
+        }
+        this.projectService.project.scenes.splice(highestSelectedSceneIndex, 0, scene);
+        this.selectScene(highestSelectedSceneIndex);
+    }
+    removeScene(scene) {
+        // remove all playback regions
+        for (const composition of this.projectService.project.compositions) {
+            for (let i = composition.scenePlaybackRegions.length - 1; i >= 0; i--) {
+                const compositionPlaybackRegion = composition.scenePlaybackRegions[i];
+                if (compositionPlaybackRegion.sceneUuid === scene.uuid) {
+                    composition.scenePlaybackRegions.splice(i, 1);
+                }
+            }
+        }
+        // remove the scene
+        this.projectService.project.scenes.splice(this.projectService.project.scenes.indexOf(scene), 1);
+        if (this.projectService.project.scenes.length > 0) {
+            this.selectScene(0);
+        }
+        this.sceneDeleted.next();
+    }
+    getSceneByUuid(uuid) {
+        for (const scene of this.projectService.project.scenes) {
+            if (scene.uuid === uuid) {
+                return scene;
+            }
+        }
+    }
+    static { this.ɵfac = function SceneService_Factory(t) { return new (t || SceneService)(i0.ɵɵinject(i1.UuidService), i0.ɵɵinject(i2.EffectService), i0.ɵɵinject(i3.PresetService), i0.ɵɵinject(i4.ProjectService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SceneService, factory: SceneService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SceneService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.UuidService }, { type: i2.EffectService }, { type: i3.PresetService }, { type: i4.ProjectService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/scene.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { Preset } from '../models/preset';\nimport { Scene } from '../models/scene';\nimport { EffectService } from './effect.service';\nimport { PresetService } from './preset.service';\nimport { ProjectService } from './project.service';\nimport { UuidService } from './uuid.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SceneService {\n  selectedScenes: Scene[] = [];\n  sceneColors: string[] = ['#945fda', '#61da5f', '#5fc3da', '#dad65f', '#da5f5f', '#246db7'];\n\n  multipleSelection = false;\n\n  sceneDeleted: Subject<void> = new Subject<void>();\n  sceneSelected: Subject<void> = new Subject<void>();\n\n  constructor(\n    private uuidService: UuidService,\n    private effectService: EffectService,\n    private presetService: PresetService,\n    private projectService: ProjectService\n  ) {}\n\n  sceneIsSelected(scene: Scene): boolean {\n    for (const selectedScene of this.selectedScenes) {\n      if (selectedScene.uuid === scene.uuid) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  presetIsSelected(preset: Preset): boolean {\n    if (!this.selectedScenes || this.selectedScenes.length !== 1) {\n      return false;\n    }\n\n    for (const uuid of this.selectedScenes[0].presetUuids) {\n      if (preset.uuid === uuid) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  switchSceneSelection(scene: Scene) {\n    // Select a scene if not yet selected or unselect it otherwise\n    if (this.sceneIsSelected(scene)) {\n      for (let i = 0; i < this.selectedScenes.length; i++) {\n        if (this.selectedScenes[i].uuid === scene.uuid) {\n          this.selectedScenes.splice(i, 1);\n          return;\n        }\n      }\n    } else {\n      this.selectedScenes.push(scene);\n    }\n\n    this.sceneSelected.next();\n  }\n\n  selectPresetFromSelectedScene() {\n    // select the first preset of the scene, if no preset of the current scene is already\n    // selected to make sure, the user does not edit a preset which is not even\n    // active in the current scene (and sees no change).\n\n    let firstPresetUuid;\n\n    // check, whether a preset of the current scene is already selected and do nothing\n    // in this case\n    for (const scene of this.selectedScenes) {\n      for (const presetUuid of scene.presetUuids) {\n        firstPresetUuid = presetUuid;\n\n        if (presetUuid === this.presetService.selectedPreset.uuid) {\n          // a preset of a currently selected scene is already selected -> do nothing\n          return;\n        }\n      }\n    }\n\n    if (!firstPresetUuid) {\n      return;\n    }\n\n    for (let i = 0; i < this.projectService.project.presets.length; i++) {\n      if (this.projectService.project.presets[i].uuid === firstPresetUuid) {\n        this.presetService.selectPreset(i);\n        break;\n      }\n    }\n  }\n\n  selectScene(index: number) {\n    this.effectService.selectedEffect = undefined;\n\n    if (index >= this.projectService.project.scenes.length) {\n      this.selectedScenes = [];\n    } else {\n      if (this.multipleSelection) {\n        this.switchSceneSelection(this.projectService.project.scenes[index]);\n      } else {\n        this.selectedScenes = [];\n        this.selectedScenes.push(this.projectService.project.scenes[index]);\n      }\n    }\n\n    this.selectPresetFromSelectedScene();\n\n    // preview the complete scene\n    this.projectService.project.previewPreset = false;\n\n    this.projectService.project.selectedSceneUuids = [];\n    for (const scene of this.selectedScenes) {\n      this.projectService.project.selectedSceneUuids.push(scene.uuid);\n    }\n    this.presetService.previewSelectionChanged.next();\n    this.presetService.previewLive();\n\n    this.sceneSelected.next();\n  }\n\n  addScene(name?: string): void {\n    const scene: Scene = new Scene();\n    scene.uuid = this.uuidService.getUuid();\n    scene.name = name || 'New Scene';\n\n    if (this.projectService.project.scenes.length < this.sceneColors.length) {\n      scene.color = this.sceneColors[this.projectService.project.scenes.length];\n    } else {\n      scene.color = '#' + Math.random().toString(16).slice(2, 8).toUpperCase();\n    }\n\n    // Insert the new scene before the highest currently selected scene\n    let highestSelectedSceneIndex = 0;\n\n    for (let i = 0; i < this.projectService.project.scenes.length; i++) {\n      if (this.sceneIsSelected(this.projectService.project.scenes[i])) {\n        highestSelectedSceneIndex = i;\n        break;\n      }\n    }\n\n    this.projectService.project.scenes.splice(highestSelectedSceneIndex, 0, scene);\n    this.selectScene(highestSelectedSceneIndex);\n  }\n\n  removeScene(scene: Scene): void {\n    // remove all playback regions\n    for (const composition of this.projectService.project.compositions) {\n      for (let i = composition.scenePlaybackRegions.length - 1; i >= 0; i--) {\n        const compositionPlaybackRegion = composition.scenePlaybackRegions[i];\n        if (compositionPlaybackRegion.sceneUuid === scene.uuid) {\n          composition.scenePlaybackRegions.splice(i, 1);\n        }\n      }\n    }\n\n    // remove the scene\n    this.projectService.project.scenes.splice(this.projectService.project.scenes.indexOf(scene), 1);\n    if (this.projectService.project.scenes.length > 0) {\n      this.selectScene(0);\n    }\n\n    this.sceneDeleted.next();\n  }\n\n  getSceneByUuid(uuid: string): Scene {\n    for (const scene of this.projectService.project.scenes) {\n      if (scene.uuid === uuid) {\n        return scene;\n      }\n    }\n  }\n}\n"]}