phoenix-ui-components 2.14.1 → 2.16.0

package/dist/esm2022/components/phoenix-ui.module.mjs

@@ -0,0 +1,254 @@
+import { ErrorHandler, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatIconModule } from '@angular/material/icon';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { CdkTreeModule } from '@angular/cdk/tree';
+import { MatTabsModule } from '@angular/material/tabs';
+import { NavComponent } from './nav/nav.component';
+import { PhoenixMenuComponent, PhoenixMenuItemComponent, ConfigSliderComponent, } from './phoenix-menu';
+import { UiMenuWrapperComponent, UiMenuComponent, CollectionsInfoComponent, MenuToggleComponent, GeometryBrowserComponent, GeometryBrowserOverlayComponent, CollectionsInfoOverlayComponent, IoOptionsComponent, IOOptionsDialogComponent, OverlayViewComponent, ObjectSelectionComponent, ObjectSelectionOverlayComponent, EventSelectorComponent, ObjectClippingComponent, DarkThemeComponent, AutoRotateComponent, CartesianGridConfigComponent, ViewOptionsComponent, OverlayViewWindowComponent, OverlayComponent, ExperimentInfoComponent, InfoPanelComponent, InfoPanelOverlayComponent, MainViewToggleComponent, ZoomControlsComponent, TreeMenuComponent, TreeMenuItemComponent, AnimateCameraComponent, AnimateEventComponent, VrToggleComponent, ArToggleComponent, SSModeComponent, MakePictureComponent, PerformanceToggleComponent, ShareLinkComponent, ShareLinkDialogComponent, EventDataExplorerComponent, EventDataExplorerDialogComponent, CycleEventsComponent, } from './ui-menu';
+import { AttributePipe } from '../services/extras/attribute.pipe';
+import { EventDisplayService } from '../services/event-display.service';
+import { ErrorMessageService } from '../services/error-message-service';
+import { GlobalErrorHandler } from '../services/global-error-handler';
+import { LoaderComponent } from './loader/loader.component';
+import { EmbedMenuComponent } from './embed-menu/embed-menu.component';
+import { ExperimentLinkComponent } from './embed-menu/experiment-link/experiment-link.component';
+import { FileExplorerComponent } from './file-explorer/file-explorer.component';
+import { RingLoaderComponent } from './ring-loader/ring-loader.component';
+import * as i0 from "@angular/core";
+const PHOENIX_COMPONENTS = [
+    NavComponent,
+    UiMenuWrapperComponent,
+    UiMenuComponent,
+    CollectionsInfoComponent,
+    GeometryBrowserComponent,
+    GeometryBrowserOverlayComponent,
+    MenuToggleComponent,
+    CollectionsInfoOverlayComponent,
+    IoOptionsComponent,
+    IOOptionsDialogComponent,
+    OverlayViewComponent,
+    AttributePipe,
+    ObjectSelectionComponent,
+    ObjectSelectionOverlayComponent,
+    EventSelectorComponent,
+    ObjectClippingComponent,
+    DarkThemeComponent,
+    AutoRotateComponent,
+    ViewOptionsComponent,
+    CartesianGridConfigComponent,
+    OverlayViewWindowComponent,
+    OverlayComponent,
+    ExperimentInfoComponent,
+    InfoPanelComponent,
+    InfoPanelOverlayComponent,
+    MainViewToggleComponent,
+    ZoomControlsComponent,
+    TreeMenuComponent,
+    TreeMenuItemComponent,
+    PhoenixMenuComponent,
+    PhoenixMenuItemComponent,
+    ConfigSliderComponent,
+    AnimateCameraComponent,
+    AnimateEventComponent,
+    VrToggleComponent,
+    ArToggleComponent,
+    SSModeComponent,
+    MakePictureComponent,
+    PerformanceToggleComponent,
+    LoaderComponent,
+    ShareLinkComponent,
+    ShareLinkDialogComponent,
+    EmbedMenuComponent,
+    ExperimentLinkComponent,
+    EventDataExplorerComponent,
+    EventDataExplorerDialogComponent,
+    FileExplorerComponent,
+    RingLoaderComponent,
+    CycleEventsComponent,
+];
+export class PhoenixUIModule {
+    static ɵfac = function PhoenixUIModule_Factory(t) { return new (t || PhoenixUIModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PhoenixUIModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            EventDisplayService,
+            ErrorMessageService,
+            {
+                provide: ErrorHandler,
+                useClass: GlobalErrorHandler,
+            },
+        ], imports: [CommonModule,
+            RouterModule,
+            DragDropModule,
+            MatDialogModule,
+            MatButtonModule,
+            MatTooltipModule,
+            OverlayModule,
+            FormsModule,
+            MatMenuModule,
+            MatRadioModule,
+            MatSliderModule,
+            MatSlideToggleModule,
+            MatCheckboxModule,
+            MatIconModule,
+            CdkTreeModule,
+            MatTabsModule] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PhoenixUIModule, [{
+        type: NgModule,
+        args: [{
+                declarations: PHOENIX_COMPONENTS,
+                imports: [
+                    CommonModule,
+                    RouterModule,
+                    DragDropModule,
+                    MatDialogModule,
+                    MatButtonModule,
+                    MatTooltipModule,
+                    OverlayModule,
+                    FormsModule,
+                    MatMenuModule,
+                    MatRadioModule,
+                    MatSliderModule,
+                    MatSlideToggleModule,
+                    MatCheckboxModule,
+                    MatIconModule,
+                    CdkTreeModule,
+                    MatTabsModule,
+                ],
+                exports: PHOENIX_COMPONENTS,
+                providers: [
+                    EventDisplayService,
+                    ErrorMessageService,
+                    {
+                        provide: ErrorHandler,
+                        useClass: GlobalErrorHandler,
+                    },
+                ],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PhoenixUIModule, { declarations: [NavComponent,
+        UiMenuWrapperComponent,
+        UiMenuComponent,
+        CollectionsInfoComponent,
+        GeometryBrowserComponent,
+        GeometryBrowserOverlayComponent,
+        MenuToggleComponent,
+        CollectionsInfoOverlayComponent,
+        IoOptionsComponent,
+        IOOptionsDialogComponent,
+        OverlayViewComponent,
+        AttributePipe,
+        ObjectSelectionComponent,
+        ObjectSelectionOverlayComponent,
+        EventSelectorComponent,
+        ObjectClippingComponent,
+        DarkThemeComponent,
+        AutoRotateComponent,
+        ViewOptionsComponent,
+        CartesianGridConfigComponent,
+        OverlayViewWindowComponent,
+        OverlayComponent,
+        ExperimentInfoComponent,
+        InfoPanelComponent,
+        InfoPanelOverlayComponent,
+        MainViewToggleComponent,
+        ZoomControlsComponent,
+        TreeMenuComponent,
+        TreeMenuItemComponent,
+        PhoenixMenuComponent,
+        PhoenixMenuItemComponent,
+        ConfigSliderComponent,
+        AnimateCameraComponent,
+        AnimateEventComponent,
+        VrToggleComponent,
+        ArToggleComponent,
+        SSModeComponent,
+        MakePictureComponent,
+        PerformanceToggleComponent,
+        LoaderComponent,
+        ShareLinkComponent,
+        ShareLinkDialogComponent,
+        EmbedMenuComponent,
+        ExperimentLinkComponent,
+        EventDataExplorerComponent,
+        EventDataExplorerDialogComponent,
+        FileExplorerComponent,
+        RingLoaderComponent,
+        CycleEventsComponent], imports: [CommonModule,
+        RouterModule,
+        DragDropModule,
+        MatDialogModule,
+        MatButtonModule,
+        MatTooltipModule,
+        OverlayModule,
+        FormsModule,
+        MatMenuModule,
+        MatRadioModule,
+        MatSliderModule,
+        MatSlideToggleModule,
+        MatCheckboxModule,
+        MatIconModule,
+        CdkTreeModule,
+        MatTabsModule], exports: [NavComponent,
+        UiMenuWrapperComponent,
+        UiMenuComponent,
+        CollectionsInfoComponent,
+        GeometryBrowserComponent,
+        GeometryBrowserOverlayComponent,
+        MenuToggleComponent,
+        CollectionsInfoOverlayComponent,
+        IoOptionsComponent,
+        IOOptionsDialogComponent,
+        OverlayViewComponent,
+        AttributePipe,
+        ObjectSelectionComponent,
+        ObjectSelectionOverlayComponent,
+        EventSelectorComponent,
+        ObjectClippingComponent,
+        DarkThemeComponent,
+        AutoRotateComponent,
+        ViewOptionsComponent,
+        CartesianGridConfigComponent,
+        OverlayViewWindowComponent,
+        OverlayComponent,
+        ExperimentInfoComponent,
+        InfoPanelComponent,
+        InfoPanelOverlayComponent,
+        MainViewToggleComponent,
+        ZoomControlsComponent,
+        TreeMenuComponent,
+        TreeMenuItemComponent,
+        PhoenixMenuComponent,
+        PhoenixMenuItemComponent,
+        ConfigSliderComponent,
+        AnimateCameraComponent,
+        AnimateEventComponent,
+        VrToggleComponent,
+        ArToggleComponent,
+        SSModeComponent,
+        MakePictureComponent,
+        PerformanceToggleComponent,
+        LoaderComponent,
+        ShareLinkComponent,
+        ShareLinkDialogComponent,
+        EmbedMenuComponent,
+        ExperimentLinkComponent,
+        EventDataExplorerComponent,
+        EventDataExplorerDialogComponent,
+        FileExplorerComponent,
+        RingLoaderComponent,
+        CycleEventsComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phoenix-ui.module.js","sourceRoot":"","sources":["../../../lib/components/phoenix-ui.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { ErrorHandler, NgModule, Type } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { RouterModule } from '@angular/router';\nimport { DragDropModule } from '@angular/cdk/drag-drop';\nimport { OverlayModule } from '@angular/cdk/overlay';\nimport { FormsModule } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatCheckboxModule } from '@angular/material/checkbox';\nimport { MatDialogModule } from '@angular/material/dialog';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatRadioModule } from '@angular/material/radio';\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\nimport { MatSliderModule } from '@angular/material/slider';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { CdkTreeModule } from '@angular/cdk/tree';\nimport { MatTabsModule } from '@angular/material/tabs';\nimport { NavComponent } from './nav/nav.component';\nimport {\n  PhoenixMenuComponent,\n  PhoenixMenuItemComponent,\n  ConfigSliderComponent,\n} from './phoenix-menu';\nimport {\n  UiMenuWrapperComponent,\n  UiMenuComponent,\n  CollectionsInfoComponent,\n  MenuToggleComponent,\n  GeometryBrowserComponent,\n  GeometryBrowserOverlayComponent,\n  CollectionsInfoOverlayComponent,\n  IoOptionsComponent,\n  IOOptionsDialogComponent,\n  OverlayViewComponent,\n  ObjectSelectionComponent,\n  ObjectSelectionOverlayComponent,\n  EventSelectorComponent,\n  ObjectClippingComponent,\n  DarkThemeComponent,\n  AutoRotateComponent,\n  CartesianGridConfigComponent,\n  ViewOptionsComponent,\n  OverlayViewWindowComponent,\n  OverlayComponent,\n  ExperimentInfoComponent,\n  InfoPanelComponent,\n  InfoPanelOverlayComponent,\n  MainViewToggleComponent,\n  ZoomControlsComponent,\n  TreeMenuComponent,\n  TreeMenuItemComponent,\n  AnimateCameraComponent,\n  AnimateEventComponent,\n  VrToggleComponent,\n  ArToggleComponent,\n  SSModeComponent,\n  MakePictureComponent,\n  PerformanceToggleComponent,\n  ShareLinkComponent,\n  ShareLinkDialogComponent,\n  EventDataExplorerComponent,\n  EventDataExplorerDialogComponent,\n  CycleEventsComponent,\n} from './ui-menu';\nimport { AttributePipe } from '../services/extras/attribute.pipe';\nimport { EventDisplayService } from '../services/event-display.service';\nimport { ErrorMessageService } from '../services/error-message-service';\nimport { GlobalErrorHandler } from '../services/global-error-handler';\nimport { LoaderComponent } from './loader/loader.component';\nimport { EmbedMenuComponent } from './embed-menu/embed-menu.component';\nimport { ExperimentLinkComponent } from './embed-menu/experiment-link/experiment-link.component';\nimport { FileExplorerComponent } from './file-explorer/file-explorer.component';\nimport { RingLoaderComponent } from './ring-loader/ring-loader.component';\n\nconst PHOENIX_COMPONENTS: Type<any>[] = [\n  NavComponent,\n  UiMenuWrapperComponent,\n  UiMenuComponent,\n  CollectionsInfoComponent,\n  GeometryBrowserComponent,\n  GeometryBrowserOverlayComponent,\n  MenuToggleComponent,\n  CollectionsInfoOverlayComponent,\n  IoOptionsComponent,\n  IOOptionsDialogComponent,\n  OverlayViewComponent,\n  AttributePipe,\n  ObjectSelectionComponent,\n  ObjectSelectionOverlayComponent,\n  EventSelectorComponent,\n  ObjectClippingComponent,\n  DarkThemeComponent,\n  AutoRotateComponent,\n  ViewOptionsComponent,\n  CartesianGridConfigComponent,\n  OverlayViewWindowComponent,\n  OverlayComponent,\n  ExperimentInfoComponent,\n  InfoPanelComponent,\n  InfoPanelOverlayComponent,\n  MainViewToggleComponent,\n  ZoomControlsComponent,\n  TreeMenuComponent,\n  TreeMenuItemComponent,\n  PhoenixMenuComponent,\n  PhoenixMenuItemComponent,\n  ConfigSliderComponent,\n  AnimateCameraComponent,\n  AnimateEventComponent,\n  VrToggleComponent,\n  ArToggleComponent,\n  SSModeComponent,\n  MakePictureComponent,\n  PerformanceToggleComponent,\n  LoaderComponent,\n  ShareLinkComponent,\n  ShareLinkDialogComponent,\n  EmbedMenuComponent,\n  ExperimentLinkComponent,\n  EventDataExplorerComponent,\n  EventDataExplorerDialogComponent,\n  FileExplorerComponent,\n  RingLoaderComponent,\n  CycleEventsComponent,\n];\n\n@NgModule({\n  declarations: PHOENIX_COMPONENTS,\n  imports: [\n    CommonModule,\n    RouterModule,\n    DragDropModule,\n    MatDialogModule,\n    MatButtonModule,\n    MatTooltipModule,\n    OverlayModule,\n    FormsModule,\n    MatMenuModule,\n    MatRadioModule,\n    MatSliderModule,\n    MatSlideToggleModule,\n    MatCheckboxModule,\n    MatIconModule,\n    CdkTreeModule,\n    MatTabsModule,\n  ],\n  exports: PHOENIX_COMPONENTS,\n  providers: [\n    EventDisplayService,\n    ErrorMessageService,\n    {\n      provide: ErrorHandler,\n      useClass: GlobalErrorHandler,\n    },\n  ],\n})\nexport class PhoenixUIModule {}\n"]}

package/dist/esm2022/components/ring-loader/ring-loader.component.mjs

@@ -0,0 +1,16 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RingLoaderComponent {
+    static ɵfac = function RingLoaderComponent_Factory(t) { return new (t || RingLoaderComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: RingLoaderComponent, selectors: [["app-ring-loader"]], decls: 5, vars: 0, consts: [[1, "ring"]], template: function RingLoaderComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0);
+            i0.ɵɵelement(1, "div")(2, "div")(3, "div")(4, "div");
+            i0.ɵɵelementEnd();
+        } }, styles: [".ring[_ngcontent-%COMP%]{display:inline-block;position:relative;width:1.5rem;height:1.5rem}.ring[_ngcontent-%COMP%]   div[_ngcontent-%COMP%]{box-sizing:border-box;display:block;position:absolute;width:1.5rem;height:1.5rem;margin:.25rem .5rem;border:.25rem solid var(--phoenix-text-color);border-radius:50%;animation:animate-ring 1.2s cubic-bezier(.5,0,.5,1) infinite;border-color:var(--phoenix-text-color) transparent transparent transparent}.ring[_ngcontent-%COMP%]   div[_ngcontent-%COMP%]:nth-child(1){animation-delay:-.45s}.ring[_ngcontent-%COMP%]   div[_ngcontent-%COMP%]:nth-child(2){animation-delay:-.3s}.ring[_ngcontent-%COMP%]   div[_ngcontent-%COMP%]:nth-child(3){animation-delay:-.15s}@keyframes _ngcontent-%COMP%_app-ring-loader_animate-ring{0%{transform:rotate(0)}to{transform:rotate(360deg)}}"] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RingLoaderComponent, [{
+        type: Component,
+        args: [{ selector: 'app-ring-loader', template: "<div class=\"ring\">\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n</div>\n", styles: [".ring{display:inline-block;position:relative;width:1.5rem;height:1.5rem}.ring div{box-sizing:border-box;display:block;position:absolute;width:1.5rem;height:1.5rem;margin:.25rem .5rem;border:.25rem solid var(--phoenix-text-color);border-radius:50%;animation:animate-ring 1.2s cubic-bezier(.5,0,.5,1) infinite;border-color:var(--phoenix-text-color) transparent transparent transparent}.ring div:nth-child(1){animation-delay:-.45s}.ring div:nth-child(2){animation-delay:-.3s}.ring div:nth-child(3){animation-delay:-.15s}@keyframes app-ring-loader_animate-ring{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"] }]
+    }], null, null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(RingLoaderComponent, { className: "RingLoaderComponent", filePath: "components/ring-loader/ring-loader.component.ts", lineNumber: 8 }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmluZy1sb2FkZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGliL2NvbXBvbmVudHMvcmluZy1sb2FkZXIvcmluZy1sb2FkZXIuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vbGliL2NvbXBvbmVudHMvcmluZy1sb2FkZXIvcmluZy1sb2FkZXIuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFPMUMsTUFBTSxPQUFPLG1CQUFtQjs2RUFBbkIsbUJBQW1COzZEQUFuQixtQkFBbUI7WUNQaEMsOEJBQWtCO1lBSWhCLEFBREEsQUFEQSxBQURBLHNCQUFXLFVBQ0EsVUFDQSxVQUNBO1lBQ2IsaUJBQU07OztpRkRFTyxtQkFBbUI7Y0FML0IsU0FBUzsyQkFDRSxpQkFBaUI7O2tGQUloQixtQkFBbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYXBwLXJpbmctbG9hZGVyJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3JpbmctbG9hZGVyLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vcmluZy1sb2FkZXIuY29tcG9uZW50LnNjc3MnXSxcbn0pXG5leHBvcnQgY2xhc3MgUmluZ0xvYWRlckNvbXBvbmVudCB7fVxuIiwiPGRpdiBjbGFzcz1cInJpbmdcIj5cbiAgPGRpdj48L2Rpdj5cbiAgPGRpdj48L2Rpdj5cbiAgPGRpdj48L2Rpdj5cbiAgPGRpdj48L2Rpdj5cbjwvZGl2PlxuIl19

package/dist/esm2022/components/ui-menu/animate-camera/animate-camera.component.mjs

@@ -0,0 +1,120 @@
+import { Component, Input } from '@angular/core';
+import { SceneManager } from 'phoenix-event-display';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/event-display.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/menu";
+import * as i4 from "../menu-toggle/menu-toggle.component";
+function AnimateCameraComponent_button_2_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 2);
+    i0.ɵɵlistener("click", function AnimateCameraComponent_button_2_Template_button_click_0_listener() { const preset_r3 = i0.ɵɵrestoreView(_r2).$implicit; const ctx_r3 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r3.animatePreset(preset_r3)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const preset_r3 = ctx.$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", preset_r3, " ");
+} }
+export const defaultAnimationPresets = {
+    'Cavern to ID': {
+        name: 'Cavern to ID',
+        positions: [
+            {
+                position: [66388.95051168812, 5264.228603228927, -46910.7848593543],
+                duration: 1000,
+            },
+            {
+                position: [12834.18729094943, 677.7571205763458, 135.68755273443463],
+                duration: 2000,
+            },
+            {
+                position: [312.02688693297375, 25.884223757326, 270.10019006776236],
+                duration: 3500,
+            },
+            {
+                position: [263.3640855132258, 19.874838262525053, -318.16541790248885],
+                duration: 3000,
+            },
+            {
+                position: [5534.140362338047, 234.03507981484574, -2933.619479808285],
+                duration: 2000,
+            },
+            {
+                position: [2681.277288705242, 646.5795158318147, 5628.5248735111745],
+                duration: 1000,
+            },
+            {
+                position: [-6062.586283740076, 790.5876682946184, 1381.1675900848818],
+                duration: 1000,
+            },
+            {
+                position: [-1766.7693725879053, 1007.1048030984678, -5928.901341784575],
+                duration: 1000,
+            },
+            {
+                position: [12814.982506255355, 2516.987185037266, -22891.902734328327],
+                duration: 1000,
+            },
+        ],
+        animateEventAfterInterval: 5000,
+        collisionDuration: 6000,
+    },
+};
+export class AnimateCameraComponent {
+    eventDisplay;
+    animationPresets = defaultAnimationPresets;
+    animationPresetsKeys = Object.keys(this.animationPresets);
+    isAnimating = false;
+    constructor(eventDisplay) {
+        this.eventDisplay = eventDisplay;
+        // this.animationPresets = this.eventDisplay
+        //   .getUIManager()
+        //   .getPresetAnimations();
+        // This is too late to fill the UI! FIXME. EJWM
+    }
+    animatePreset(preset) {
+        this.setDetectorOpacity(0.2);
+        this.eventDisplay.animatePreset(this.animationPresets[preset], () => {
+            this.setDetectorOpacity(1);
+        });
+    }
+    animateCamera() {
+        if (!this.isAnimating) {
+            this.isAnimating = true;
+            this.eventDisplay.animateThroughEvent([11976, 7262, 11927], 3000, () => {
+                this.isAnimating = false;
+            });
+        }
+    }
+    setDetectorOpacity(opacity) {
+        const sceneManager = this.eventDisplay.getThreeManager().getSceneManager();
+        const geometriesGroup = sceneManager.getObjectByName(SceneManager.GEOMETRIES_ID);
+        sceneManager.setGeometryOpacity(geometriesGroup, opacity);
+    }
+    static ɵfac = function AnimateCameraComponent_Factory(t) { return new (t || AnimateCameraComponent)(i0.ɵɵdirectiveInject(i1.EventDisplayService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: AnimateCameraComponent, selectors: [["app-animate-camera"]], inputs: { animationPresets: "animationPresets" }, decls: 6, vars: 2, consts: [["animationPresets", ""], ["mat-menu-item", "", 3, "click", 4, "ngFor", "ngForOf"], ["mat-menu-item", "", 3, "click"], ["tooltip", "Preset animations", "icon", "animate-camera", 3, "matMenuTriggerFor"]], template: function AnimateCameraComponent_Template(rf, ctx) { if (rf & 1) {
+            const _r1 = i0.ɵɵgetCurrentView();
+            i0.ɵɵelementStart(0, "mat-menu", null, 0);
+            i0.ɵɵtemplate(2, AnimateCameraComponent_button_2_Template, 2, 1, "button", 1);
+            i0.ɵɵelementStart(3, "button", 2);
+            i0.ɵɵlistener("click", function AnimateCameraComponent_Template_button_click_3_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.animateCamera()); });
+            i0.ɵɵtext(4, "Animate camera");
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelement(5, "app-menu-toggle", 3);
+        } if (rf & 2) {
+            const animationPresets_r5 = i0.ɵɵreference(1);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngForOf", ctx.animationPresetsKeys);
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("matMenuTriggerFor", animationPresets_r5);
+        } }, dependencies: [i2.NgForOf, i3.MatMenu, i3.MatMenuItem, i3.MatMenuTrigger, i4.MenuToggleComponent] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AnimateCameraComponent, [{
+        type: Component,
+        args: [{ selector: 'app-animate-camera', template: "<mat-menu #animationPresets>\n  <button\n    mat-menu-item\n    *ngFor=\"let preset of animationPresetsKeys\"\n    (click)=\"animatePreset(preset)\"\n  >\n    {{ preset }}\n  </button>\n  <button mat-menu-item (click)=\"animateCamera()\">Animate camera</button>\n</mat-menu>\n\n<app-menu-toggle\n  [matMenuTriggerFor]=\"animationPresets\"\n  tooltip=\"Preset animations\"\n  icon=\"animate-camera\"\n>\n</app-menu-toggle>\n" }]
+    }], () => [{ type: i1.EventDisplayService }], { animationPresets: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(AnimateCameraComponent, { className: "AnimateCameraComponent", filePath: "components/ui-menu/animate-camera/animate-camera.component.ts", lineNumber: 58 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/components/ui-menu/animate-event/animate-event.component.mjs

@@ -0,0 +1,33 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/event-display.service";
+import * as i2 from "../menu-toggle/menu-toggle.component";
+export class AnimateEventComponent {
+    eventDisplay;
+    isAnimating = false;
+    constructor(eventDisplay) {
+        this.eventDisplay = eventDisplay;
+    }
+    toggleAnimateEvent() {
+        if (!this.isAnimating) {
+            this.isAnimating = true;
+            this.eventDisplay.animateEventWithCollision(10000, () => {
+                this.isAnimating = false;
+            });
+        }
+    }
+    static ɵfac = function AnimateEventComponent_Factory(t) { return new (t || AnimateEventComponent)(i0.ɵɵdirectiveInject(i1.EventDisplayService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: AnimateEventComponent, selectors: [["app-animate-event"]], decls: 1, vars: 1, consts: [["tooltip", "Animate event", "icon", "event-folder", 3, "click", "active"]], template: function AnimateEventComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "app-menu-toggle", 0);
+            i0.ɵɵlistener("click", function AnimateEventComponent_Template_app_menu_toggle_click_0_listener() { return ctx.toggleAnimateEvent(); });
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("active", ctx.isAnimating);
+        } }, dependencies: [i2.MenuToggleComponent] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AnimateEventComponent, [{
+        type: Component,
+        args: [{ selector: 'app-animate-event', template: "<app-menu-toggle\n  tooltip=\"Animate event\"\n  icon=\"event-folder\"\n  [active]=\"isAnimating\"\n  (click)=\"toggleAnimateEvent()\"\n>\n</app-menu-toggle>\n" }]
+    }], () => [{ type: i1.EventDisplayService }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(AnimateEventComponent, { className: "AnimateEventComponent", filePath: "components/ui-menu/animate-event/animate-event.component.ts", lineNumber: 9 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/components/ui-menu/ar-toggle/ar-toggle.component.mjs

@@ -0,0 +1,83 @@
+import { Component } from '@angular/core';
+import { ARManager, XRSessionType } from 'phoenix-event-display';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/event-display.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/menu";
+import * as i4 from "../menu-toggle/menu-toggle.component";
+function ArToggleComponent_ng_container_2_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "button", 4);
+    i0.ɵɵlistener("click", function ArToggleComponent_ng_container_2_Template_button_click_1_listener() { i0.ɵɵrestoreView(_r2); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.toggleAr(true)); });
+    i0.ɵɵtext(2, "AR with overlays");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(3, "button", 4);
+    i0.ɵɵlistener("click", function ArToggleComponent_ng_container_2_Template_button_click_3_listener() { i0.ɵɵrestoreView(_r2); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.toggleAr(false)); });
+    i0.ɵɵtext(4, "AR without overlays");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} }
+function ArToggleComponent_button_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "button", 5);
+    i0.ɵɵtext(1, "AR not supported");
+    i0.ɵɵelementEnd();
+} }
+export class ArToggleComponent {
+    eventDisplay;
+    arSupported = false;
+    arActive = false;
+    constructor(eventDisplay) {
+        this.eventDisplay = eventDisplay;
+        // NOTE: WebXR needs secure HTTPS context
+        // Query for permissions of XR before using it (not supported by browsers yet). See https://developer.mozilla.org/en-US/docs/Web/API/Permissions/query
+        navigator.xr
+            ?.isSessionSupported?.(ARManager.SESSION_TYPE)
+            .then((supported) => {
+            if (supported) {
+                this.arSupported = true;
+            }
+        })
+            .catch((err) => console.warn('Error in AR', err));
+    }
+    toggleAr(enableDomOverlay = true) {
+        ARManager.enableDomOverlay = enableDomOverlay;
+        // If toggling AR on
+        if (!this.arActive) {
+            this.eventDisplay.initXR(XRSessionType.AR, () => {
+                this.arActive = false;
+                // Disable renderer XR and remove animation loop
+                this.eventDisplay.endXR(XRSessionType.AR);
+            });
+            this.arActive = true;
+        }
+        else {
+            this.eventDisplay.endXR(XRSessionType.AR);
+            this.arActive = false;
+        }
+    }
+    static ɵfac = function ArToggleComponent_Factory(t) { return new (t || ArToggleComponent)(i0.ɵɵdirectiveInject(i1.EventDisplayService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ArToggleComponent, selectors: [["app-ar-toggle"]], decls: 5, vars: 6, consts: [["arToggleOptions", ""], [4, "ngIf"], ["mat-menu-item", "", "disabled", "", 4, "ngIf"], ["icon", "ar", 3, "click", "matMenuTriggerFor", "disabled", "active", "tooltip"], ["mat-menu-item", "", 3, "click"], ["mat-menu-item", "", "disabled", ""]], template: function ArToggleComponent_Template(rf, ctx) { if (rf & 1) {
+            const _r1 = i0.ɵɵgetCurrentView();
+            i0.ɵɵelementStart(0, "mat-menu", null, 0);
+            i0.ɵɵtemplate(2, ArToggleComponent_ng_container_2_Template, 5, 0, "ng-container", 1)(3, ArToggleComponent_button_3_Template, 2, 0, "button", 2);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(4, "app-menu-toggle", 3);
+            i0.ɵɵlistener("click", function ArToggleComponent_Template_app_menu_toggle_click_4_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.arSupported && (ctx.arActive ? ctx.toggleAr() : null)); });
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            const arToggleOptions_r4 = i0.ɵɵreference(1);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", ctx.arSupported);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", !ctx.arSupported);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("matMenuTriggerFor", arToggleOptions_r4)("disabled", !ctx.arSupported)("active", ctx.arActive)("tooltip", ctx.arSupported ? ctx.arActive ? "Exit AR" : "Enter AR" : "AR not supported");
+        } }, dependencies: [i2.NgIf, i3.MatMenu, i3.MatMenuItem, i3.MatMenuTrigger, i4.MenuToggleComponent] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArToggleComponent, [{
+        type: Component,
+        args: [{ selector: 'app-ar-toggle', template: "<mat-menu #arToggleOptions>\n  <ng-container *ngIf=\"arSupported\">\n    <button mat-menu-item (click)=\"toggleAr(true)\">AR with overlays</button>\n    <button mat-menu-item (click)=\"toggleAr(false)\">AR without overlays</button>\n  </ng-container>\n  <button *ngIf=\"!arSupported\" mat-menu-item disabled>AR not supported</button>\n</mat-menu>\n\n<app-menu-toggle\n  [matMenuTriggerFor]=\"arToggleOptions\"\n  (click)=\"arSupported && (arActive ? toggleAr() : null)\"\n  [disabled]=\"!arSupported\"\n  [active]=\"arActive\"\n  icon=\"ar\"\n  [tooltip]=\"\n    arSupported ? (arActive ? 'Exit AR' : 'Enter AR') : 'AR not supported'\n  \"\n>\n</app-menu-toggle>\n" }]
+    }], () => [{ type: i1.EventDisplayService }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ArToggleComponent, { className: "ArToggleComponent", filePath: "components/ui-menu/ar-toggle/ar-toggle.component.ts", lineNumber: 10 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/components/ui-menu/auto-rotate/auto-rotate.component.mjs

@@ -0,0 +1,29 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/event-display.service";
+import * as i2 from "../menu-toggle/menu-toggle.component";
+export class AutoRotateComponent {
+    eventDisplay;
+    autoRotate = false;
+    constructor(eventDisplay) {
+        this.eventDisplay = eventDisplay;
+    }
+    toggleAutoRotate() {
+        this.autoRotate = !this.autoRotate;
+        this.eventDisplay.getUIManager().setAutoRotate(this.autoRotate);
+    }
+    static ɵfac = function AutoRotateComponent_Factory(t) { return new (t || AutoRotateComponent)(i0.ɵɵdirectiveInject(i1.EventDisplayService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: AutoRotateComponent, selectors: [["app-auto-rotate"]], decls: 1, vars: 1, consts: [["tooltip", "Auto rotate", "icon", "rotate", 3, "click", "active"]], template: function AutoRotateComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "app-menu-toggle", 0);
+            i0.ɵɵlistener("click", function AutoRotateComponent_Template_app_menu_toggle_click_0_listener() { return ctx.toggleAutoRotate(); });
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("active", ctx.autoRotate);
+        } }, dependencies: [i2.MenuToggleComponent] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AutoRotateComponent, [{
+        type: Component,
+        args: [{ selector: 'app-auto-rotate', template: "<app-menu-toggle\n  tooltip=\"Auto rotate\"\n  icon=\"rotate\"\n  [active]=\"autoRotate\"\n  (click)=\"toggleAutoRotate()\"\n>\n</app-menu-toggle>\n" }]
+    }], () => [{ type: i1.EventDisplayService }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(AutoRotateComponent, { className: "AutoRotateComponent", filePath: "components/ui-menu/auto-rotate/auto-rotate.component.ts", lineNumber: 9 }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1yb3RhdGUuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGliL2NvbXBvbmVudHMvdWktbWVudS9hdXRvLXJvdGF0ZS9hdXRvLXJvdGF0ZS5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi9saWIvY29tcG9uZW50cy91aS1tZW51L2F1dG8tcm90YXRlL2F1dG8tcm90YXRlLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7Ozs7QUFRMUMsTUFBTSxPQUFPLG1CQUFtQjtJQUdWO0lBRnBCLFVBQVUsR0FBRyxLQUFLLENBQUM7SUFFbkIsWUFBb0IsWUFBaUM7UUFBakMsaUJBQVksR0FBWixZQUFZLENBQXFCO0lBQUcsQ0FBQztJQUV6RCxnQkFBZ0I7UUFDZCxJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQztRQUNuQyxJQUFJLENBQUMsWUFBWSxDQUFDLFlBQVksRUFBRSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDbEUsQ0FBQzs2RUFSVSxtQkFBbUI7NkRBQW5CLG1CQUFtQjtZQ1JoQywwQ0FLQztZQURDLHlHQUFTLHNCQUFrQixJQUFDO1lBRTlCLGlCQUFrQjs7WUFIaEIsdUNBQXFCOzs7aUZES1YsbUJBQW1CO2NBTC9CLFNBQVM7MkJBQ0UsaUJBQWlCOztrRkFJaEIsbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBFdmVudERpc3BsYXlTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vc2VydmljZXMvZXZlbnQtZGlzcGxheS5zZXJ2aWNlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYXBwLWF1dG8tcm90YXRlJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2F1dG8tcm90YXRlLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vYXV0by1yb3RhdGUuY29tcG9uZW50LnNjc3MnXSxcbn0pXG5leHBvcnQgY2xhc3MgQXV0b1JvdGF0ZUNvbXBvbmVudCB7XG4gIGF1dG9Sb3RhdGUgPSBmYWxzZTtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGV2ZW50RGlzcGxheTogRXZlbnREaXNwbGF5U2VydmljZSkge31cblxuICB0b2dnbGVBdXRvUm90YXRlKCkge1xuICAgIHRoaXMuYXV0b1JvdGF0ZSA9ICF0aGlzLmF1dG9Sb3RhdGU7XG4gICAgdGhpcy5ldmVudERpc3BsYXkuZ2V0VUlNYW5hZ2VyKCkuc2V0QXV0b1JvdGF0ZSh0aGlzLmF1dG9Sb3RhdGUpO1xuICB9XG59XG4iLCI8YXBwLW1lbnUtdG9nZ2xlXG4gIHRvb2x0aXA9XCJBdXRvIHJvdGF0ZVwiXG4gIGljb249XCJyb3RhdGVcIlxuICBbYWN0aXZlXT1cImF1dG9Sb3RhdGVcIlxuICAoY2xpY2spPVwidG9nZ2xlQXV0b1JvdGF0ZSgpXCJcbj5cbjwvYXBwLW1lbnUtdG9nZ2xlPlxuIl19