@smartsoft001-mobilems/angular 2.78.0 → 2.79.0

package/fesm2022/smartsoft001-mobilems-angular.mjs

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from 'tslib';
 import * as i0 from '@angular/core';
-import { Injectable, inject, PLATFORM_ID, signal, effect, computed, input, output, HostListener, Component, ApplicationRef, EnvironmentInjector, createComponent, InjectionToken, Directive, contentChild, Inject, viewChild, ElementRef, APP_INITIALIZER, NgModule } from '@angular/core';
+import { Injectable, inject, PLATFORM_ID, signal, effect, computed, input, output, HostListener, Component, ApplicationRef, EnvironmentInjector, createComponent, InjectionToken, Directive, contentChild, Inject, NgZone, viewChild, model, ElementRef, APP_INITIALIZER, NgModule } from '@angular/core';
 import { Meta, Title, DomSanitizer } from '@angular/platform-browser';
 import { StyleService as StyleService$1, ReduxAction, AppBaseComponent, PageBaseComponent, BaseComponent } from '@smartsoft001/angular';
 import { HttpClient } from '@angular/common/http';
@@ -14,10 +14,12 @@ import { TranslateService } from '@ngx-translate/core';
 import { CrudSearchService, CrudService, CrudFacade } from '@smartsoft001/crud-shell-angular';
 import * as _ from 'lodash';
 import { Debounce } from 'lodash-decorators';
+import Swiper from 'swiper';
+import { Navigation, Autoplay } from 'swiper/modules';
+import { toSignal } from '@angular/core/rxjs-interop';
 import { ConfigPageType, ArticleWidgetType } from '@smartsoft001-mobilems/models';
 import { Masonry } from '@thisissoon/angular-masonry';
 import { capitalize } from '@smartsoft001/utils';
-import { toSignal } from '@angular/core/rxjs-interop';
 
 function setTranslationsAndLang(service) {
     const map = {
@@ -272,7 +274,9 @@ class FileUrlService {
         if (path[0] === '/') {
             path = path.substring(1);
         }
-        const shouldSkipExtensionReplacement = isStringPath || path.includes('media/dictionaries') || path.includes('media/articles');
+        const shouldSkipExtensionReplacement = isStringPath ||
+            path.includes('media/dictionaries') ||
+            path.includes('media/articles');
         if (!shouldSkipExtensionReplacement) {
             path = this.replaceExtensionIfCache(path, mode);
         }
@@ -1565,6 +1569,12 @@ class FiltersContext extends BaseComponent {
     get authors() {
         return this.filterGet('=', 'authors');
     }
+    set formFeature(val) {
+        this.filterSet(this.formFeature, val, 'formFeature', '=');
+    }
+    get formFeature() {
+        return this.filterGet('=', 'formFeature');
+    }
     set targetGroups(val) {
         this.filterSet(this.targetGroups, val, 'targetGroups', '=');
     }
@@ -1589,6 +1599,12 @@ class FiltersContext extends BaseComponent {
     get extraNumbersValue() {
         return this.filterGet('=', 'extraNumbersValue');
     }
+    set inventoryNumber(val) {
+        this.filterSet(this.inventoryNumber, val, 'inventoryNumber', '=');
+    }
+    get inventoryNumber() {
+        return this.filterGet('=', 'inventoryNumber');
+    }
     set filters(filters) {
         this.multipleFilterSet(filters?.map(({ val, key, type }) => ({
             currentValue: this.filterGet(type, key),
@@ -1745,6 +1761,790 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImpor
                 args: ['window:scroll', []]
             }] } });
 
+class SliderBaseComponent {
+    constructor() {
+        this.fileUrlService = inject(FileUrlService);
+        this.slides = input([], ...(ngDevMode ? [{ debugName: "slides" }] : []));
+        this.autoplayEnabled = signal(true, ...(ngDevMode ? [{ debugName: "autoplayEnabled" }] : []));
+        this.windowWidth = signal(typeof window !== 'undefined' ? window.innerWidth : 1024, ...(ngDevMode ? [{ debugName: "windowWidth" }] : []));
+        // Computed signal that recalculates images when windowWidth or slides change
+        this.slideImages = computed(() => {
+            const width = this.windowWidth();
+            const slides = this.slides();
+            return slides.map((slide) => {
+                let imageSource;
+                if (width < 768) {
+                    imageSource =
+                        slide.imageMobile || slide.imageTablet || slide.imageDesktop;
+                }
+                else if (width < 1024) {
+                    imageSource =
+                        slide.imageTablet || slide.imageDesktop || slide.imageMobile;
+                }
+                else {
+                    imageSource =
+                        slide.imageDesktop || slide.imageTablet || slide.imageMobile;
+                }
+                if (!imageSource) {
+                    return '/gfx/no-image.png';
+                }
+                return this.fileUrlService.get(imageSource);
+            });
+        }, ...(ngDevMode ? [{ debugName: "slideImages" }] : []));
+        this.ngZone = inject(NgZone);
+        this.swiperContainer = viewChild('swiperContainer', ...(ngDevMode ? [{ debugName: "swiperContainer" }] : []));
+        effect(() => {
+            const slides = this.slides();
+            if (this.swiper && slides.length > 0) {
+                this.swiper.update();
+            }
+        });
+    }
+    ngOnInit() {
+        this.initSwiper();
+        // Listen to window resize to recreate swiper completely
+        this.resizeListener = () => {
+            this.ngZone.run(() => {
+                this.windowWidth.set(window.innerWidth);
+                this.recreateSwiper();
+            });
+        };
+        window.addEventListener('resize', this.resizeListener);
+    }
+    ngOnDestroy() {
+        if (this.resizeListener && typeof window !== 'undefined') {
+            window.removeEventListener('resize', this.resizeListener);
+        }
+        if (this.swiper) {
+            this.swiper.destroy(true, true);
+        }
+    }
+    toggleAutoplay() {
+        this.autoplayEnabled.update((current) => !current);
+        if (this.swiper) {
+            if (this.autoplayEnabled()) {
+                this.swiper.params.autoplay = {
+                    delay: 5000,
+                    disableOnInteraction: false,
+                };
+                this.swiper.autoplay.start();
+            }
+            else {
+                this.swiper.autoplay.stop();
+            }
+        }
+    }
+    getImage(slide) {
+        let imageSource;
+        if (typeof window !== 'undefined') {
+            const width = window.innerWidth;
+            if (width < 768) {
+                imageSource =
+                    slide.imageMobile || slide.imageTablet || slide.imageDesktop;
+            }
+            else if (width < 1024) {
+                imageSource =
+                    slide.imageTablet || slide.imageDesktop || slide.imageMobile;
+            }
+            else {
+                imageSource =
+                    slide.imageDesktop || slide.imageTablet || slide.imageMobile;
+            }
+        }
+        else {
+            imageSource =
+                slide.imageDesktop || slide.imageTablet || slide.imageMobile;
+        }
+        // Return the image source directly if it's a URL, otherwise use FileUrlService
+        if (!imageSource) {
+            return '/gfx/no-image.png';
+        }
+        return this.fileUrlService.get(imageSource);
+    }
+    initSwiper() {
+        const container = this.swiperContainer();
+        if (!container)
+            return;
+        // if (isPlatformServer(this.platformId)) return;
+        this.swiper = new Swiper(container.nativeElement, {
+            modules: [Navigation, Autoplay],
+            loop: true,
+            autoplay: {
+                delay: 5000,
+                disableOnInteraction: false,
+            },
+            navigation: {
+                nextEl: '.swiper-button-next',
+                prevEl: '.swiper-button-prev',
+            },
+            slidesPerView: 1,
+            spaceBetween: 0,
+        });
+    }
+    recreateSwiper() {
+        const container = this.swiperContainer();
+        if (!container)
+            return;
+        // Destroy existing swiper
+        if (this.swiper) {
+            this.swiper.destroy(true, true);
+            this.swiper = undefined;
+        }
+        // Small delay to ensure DOM is updated after signal change
+        setTimeout(() => {
+            this.createSwiper(container.nativeElement);
+        }, 0);
+    }
+    createSwiper(element) {
+        this.swiper = new Swiper(element, {
+            modules: [Navigation, Autoplay],
+            loop: true,
+            autoplay: {
+                delay: 5000,
+                disableOnInteraction: false,
+            },
+            navigation: {
+                nextEl: '.swiper-button-next',
+                prevEl: '.swiper-button-prev',
+            },
+            slidesPerView: 1,
+            spaceBetween: 0,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SliderBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "20.1.0", type: SliderBaseComponent, isStandalone: true, inputs: { slides: { classPropertyName: "slides", publicName: "slides", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "swiperContainer", first: true, predicate: ["swiperContainer"], descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SliderBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+
+class SearchBaseComponent {
+    constructor() {
+        this.route = inject(ActivatedRoute);
+        this.router = inject(Router);
+        this.service = inject(SearchService);
+        this.params = toSignal(this.route.params);
+        this.text = signal('', ...(ngDevMode ? [{ debugName: "text" }] : []));
+        this.data = signal(null, ...(ngDevMode ? [{ debugName: "data" }] : []));
+        this.tabs = signal([], ...(ngDevMode ? [{ debugName: "tabs" }] : []));
+        this.searchMap = {
+            fallbackId: 'obiekty',
+            fallbackLabel: 'Obiekty',
+            fallbackProperty: 'objects',
+            searchTabs: [],
+        };
+        this.activeTab = signal(this.searchMap.fallbackId, ...(ngDevMode ? [{ debugName: "activeTab" }] : []));
+        effect(async () => {
+            const { text } = this.params();
+            this.text.set(text);
+            const data = await firstValueFrom(this.service.search(text ? text : '_'));
+            let path = this.searchMap.fallbackId;
+            const tabs = [];
+            for (const tab of this.searchMap.searchTabs) {
+                if (data[tab.property]) {
+                    tabs.push({
+                        id: tab.id,
+                        label: `${tab.label} (${data[tab.property]})`,
+                    });
+                }
+            }
+            if (!tabs.length) {
+                tabs.push({
+                    id: this.searchMap.fallbackId,
+                    label: `${this.searchMap.fallbackLabel} (${data[this.searchMap.fallbackProperty]})`,
+                });
+            }
+            for (const tab of this.searchMap.searchTabs) {
+                if (data[tab.property]) {
+                    path = tab.id;
+                    break;
+                }
+            }
+            this.data.set(data);
+            this.tabs.set(tabs);
+            this.activeTab.set(path);
+            await this.router.navigate([`/wyszukaj/${text}/${path}`]);
+        });
+        effect(() => {
+            const activeTab = this.activeTab();
+            const text = this.text();
+            this.router.navigate([`/wyszukaj/${text}/${activeTab}`]);
+        });
+    }
+    ngOnInit() {
+        this.service.setEnabled(true);
+    }
+    ngOnDestroy() {
+        this.service.setEnabled(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SearchBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.0", type: SearchBaseComponent, isStandalone: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SearchBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+
+class MediaTabBaseComponent {
+    constructor() {
+        this.item = input.required(...(ngDevMode ? [{ debugName: "item" }] : []));
+        this.formFeatureTypes = input.required(...(ngDevMode ? [{ debugName: "formFeatureTypes" }] : []));
+        this.models = computed(() => {
+            const obj = this.item();
+            let filtered = [];
+            if (obj.additionalImages && Array.isArray(obj.additionalImages)) {
+                filtered = obj.additionalImages
+                    .filter((file) => file?.formFeature
+                    ? this.formFeatureTypes().includes(file.formFeature)
+                    : false)
+                    .sort((a, b) => (a?.position ?? 0) - (b?.position ?? 0));
+            }
+            return filtered;
+        }, ...(ngDevMode ? [{ debugName: "models" }] : []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: MediaTabBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.1.0", type: MediaTabBaseComponent, isStandalone: true, inputs: { item: { classPropertyName: "item", publicName: "item", isSignal: true, isRequired: true, transformFunction: null }, formFeatureTypes: { classPropertyName: "formFeatureTypes", publicName: "formFeatureTypes", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: MediaTabBaseComponent, decorators: [{
+            type: Directive
+        }] });
+
+class GalleryFullscreenBaseComponent {
+    constructor() {
+        this.fileUrlService = inject(FileUrlService);
+        this.document = inject(DOCUMENT);
+        this.ngZone = inject(NgZone);
+        this.items = input(...(ngDevMode ? [undefined, { debugName: "items" }] : []));
+        this.alt = input('', ...(ngDevMode ? [{ debugName: "alt" }] : []));
+        this.id = input('imagePreview', ...(ngDevMode ? [{ debugName: "id" }] : []));
+        this.selectedIndex = model(0, ...(ngDevMode ? [{ debugName: "selectedIndex" }] : []));
+        this.closeChange = output();
+        // Touch pinch gesture tracking
+        this.touchStartDistance = 0;
+        this.touchStartZoom = 1;
+        // Pinch midpoint (client coords) and transform at start of pinch
+        this.pinchStartClientX = 0;
+        this.pinchStartClientY = 0;
+        this.pinchStartTransformX = 0;
+        this.pinchStartTransformY = 0;
+        // Pan/drag gesture tracking
+        this.isPanning = signal(false, ...(ngDevMode ? [{ debugName: "isPanning" }] : []));
+        this.panStartX = 0;
+        this.panStartY = 0;
+        this.panStartTransformX = 0;
+        this.panStartTransformY = 0;
+        this.touchStartedOnButton = false;
+        this.canGoPrevious = computed(() => this.fullscreenIndex() > 0, ...(ngDevMode ? [{ debugName: "canGoPrevious" }] : []));
+        this.canGoNext = computed(() => {
+            const items = this.items();
+            return items && this.fullscreenIndex() < items.length - 1;
+        }, ...(ngDevMode ? [{ debugName: "canGoNext" }] : []));
+        // Fullscreen state
+        this.fullscreenIndex = signal(0, ...(ngDevMode ? [{ debugName: "fullscreenIndex" }] : []));
+        this.zoomLevel = signal(1, ...(ngDevMode ? [{ debugName: "zoomLevel" }] : []));
+        this.rotation = signal(0, ...(ngDevMode ? [{ debugName: "rotation" }] : []));
+        this.transform = computed(() => {
+            const trans = this.imageTransform();
+            return `
+    translate(${trans.x}px, ${trans.y}px)
+    scale(${this.zoomLevel()})
+    rotate(${this.rotation()}deg)
+  `;
+        }, ...(ngDevMode ? [{ debugName: "transform" }] : []));
+        this.imageTransform = signal({ x: 0, y: 0 }, ...(ngDevMode ? [{ debugName: "imageTransform" }] : []));
+        // Loading indicator for fullscreen image
+        this.isFullscreenLoading = signal(true, ...(ngDevMode ? [{ debugName: "isFullscreenLoading" }] : []));
+        this.fullscreenItem = computed(() => {
+            const items = this.items();
+            const index = this.fullscreenIndex();
+            if (!items)
+                return null;
+            return items[index] || null;
+        }, ...(ngDevMode ? [{ debugName: "fullscreenItem" }] : []));
+        // OpenSeadragon viewer instance
+        this.osdViewer = null;
+        this.openseadragonModule = null;
+        this.osdContainerId = computed(() => `osd-viewer-${this.id()}`, ...(ngDevMode ? [{ debugName: "osdContainerId" }] : []));
+        // Reset fullscreen zoom when changing images
+        effect(() => {
+            this.fullscreenIndex();
+            this.zoomLevel.set(1);
+            this.imageTransform.set({ x: 0, y: 0 });
+            this.rotation.set(0);
+            // Load new image in OpenSeadragon if viewer exists
+            if (this.osdViewer) {
+                const item = this.fullscreenItem();
+                if (item?.image) {
+                    this.loadOsdImage(item.image);
+                }
+            }
+        });
+    }
+    ngAfterViewInit() {
+        this.initFullscreen();
+    }
+    ngOnDestroy() {
+        this.stopLoading();
+        this.zoomLevel.set(1);
+        this.imageTransform.set({ x: 0, y: 0 });
+        this.document.body.classList.remove('smart-gallery-fullscreen-active');
+        // Destroy OpenSeadragon viewer
+        if (this.osdViewer) {
+            this.ngZone.runOutsideAngular(() => {
+                try {
+                    this.osdViewer.destroy();
+                }
+                catch (e) {
+                    // Ignore errors
+                }
+            });
+            this.osdViewer = null;
+        }
+    }
+    async initFullscreen() {
+        this.fullscreenIndex.set(this.selectedIndex());
+        this.document.body.classList.add('smart-gallery-fullscreen-active');
+        const item = this.fullscreenItem();
+        if (!item?.image)
+            return;
+        try {
+            // Lazy load OpenSeadragon
+            if (!this.openseadragonModule) {
+                this.openseadragonModule = await import('openseadragon');
+            }
+            // Wait for template to render
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            const container = this.document.getElementById(this.osdContainerId());
+            if (!container) {
+                this.startLoading();
+                return;
+            }
+            // Create viewer outside Angular zone for better performance
+            if (!this.osdViewer) {
+                this.osdViewer = this.ngZone.runOutsideAngular(() => {
+                    const viewer = this.openseadragonModule.default({
+                        element: container,
+                        prefixUrl: 'https://openseadragon.github.io/openseadragon/images/',
+                        animationTime: 0.5,
+                        blendTime: 0.1,
+                        constrainDuringPan: true,
+                        maxZoomPixelRatio: 2,
+                        minZoomLevel: 0,
+                        visibilityRatio: 1,
+                        zoomPerScroll: 1.2,
+                        showNavigator: false,
+                        showNavigationControl: false,
+                        gestureSettingsMouse: {
+                            scrollToZoom: true,
+                            clickToZoom: false,
+                            dblClickToZoom: true,
+                            pinchToZoom: true,
+                            flickEnabled: true,
+                            flickMinSpeed: 0.5,
+                            flickMomentum: 0.25,
+                        },
+                        gestureSettingsTouch: {
+                            scrollToZoom: false,
+                            clickToZoom: false,
+                            dblClickToZoom: true,
+                            pinchToZoom: true,
+                            flickEnabled: true,
+                            flickMinSpeed: 0.5,
+                            flickMomentum: 0.25,
+                        },
+                    });
+                    // Sync zoom level with component state (run inside Angular zone)
+                    viewer.addHandler('open', () => {
+                        this.ngZone.run(() => {
+                            this.stopLoading();
+                            try {
+                                const viewport = viewer.viewport;
+                                viewport.setRotation(0);
+                                viewport.goHome(true);
+                                this.rotation.set(0);
+                                const homeZoom = viewer.viewport.getHomeZoom();
+                                // Dynamically set minZoomLevel to 50% of home zoom
+                                // This ensures all images can zoom out to exactly 50% regardless of aspect ratio
+                                viewer.viewport.minZoomLevel = homeZoom * 0.5;
+                                const currentZoom = viewer.viewport.getZoom();
+                                // Normalize: 100% = fit to screen (home zoom)
+                                const normalizedZoom = currentZoom / homeZoom;
+                                this.zoomLevel.set(normalizedZoom);
+                            }
+                            catch (e) {
+                                this.zoomLevel.set(1);
+                                this.rotation.set(0);
+                            }
+                        });
+                    });
+                    viewer.addHandler('zoom', () => {
+                        this.ngZone.run(() => {
+                            try {
+                                const homeZoom = viewer.viewport.getHomeZoom();
+                                const currentZoom = viewer.viewport.getZoom();
+                                const normalizedZoom = currentZoom / homeZoom;
+                                this.zoomLevel.set(normalizedZoom);
+                            }
+                            catch (e) {
+                                // Ignore errors
+                            }
+                        });
+                    });
+                    return viewer;
+                });
+            }
+            // Load image into OpenSeadragon
+            await this.loadOsdImage(item.image);
+        }
+        catch (error) {
+            console.error('Failed to initialize OpenSeadragon:', error);
+            this.startLoading();
+        }
+    }
+    // Called from template when fullscreen image loads or fails
+    onFullscreenImageLoad() {
+        this.stopLoading();
+    }
+    startLoading() {
+        this.isFullscreenLoading.set(true);
+    }
+    stopLoading() {
+        this.isFullscreenLoading.set(false);
+    }
+    closeFullscreen() {
+        this.closeChange.emit();
+    }
+    rotateRight() {
+        this.rotation.update((r) => (r + 90) % 360);
+        if (this.osdViewer) {
+            this.ngZone.runOutsideAngular(() => {
+                try {
+                    const viewport = this.osdViewer.viewport;
+                    viewport.setRotation(this.rotation());
+                    viewport.applyConstraints();
+                }
+                catch (e) {
+                    return;
+                }
+            });
+        }
+    }
+    handleKeyboardEvent(event) {
+        switch (event.key) {
+            case 'Escape':
+                this.closeFullscreen();
+                event.preventDefault();
+                break;
+            case 'ArrowLeft':
+                this.previousImage();
+                event.preventDefault();
+                break;
+            case 'ArrowRight':
+                this.nextImage();
+                event.preventDefault();
+                break;
+            case '+':
+            case '=':
+                this.zoomIn();
+                event.preventDefault();
+                break;
+            case '-':
+                this.zoomOut();
+                event.preventDefault();
+                break;
+            case '0':
+                this.resetZoom();
+                event.preventDefault();
+                break;
+        }
+    }
+    handleTouchStart(event) {
+        // Check if touch started on a button
+        const target = event.target;
+        this.touchStartedOnButton = !!target.closest('button');
+        if (this.touchStartedOnButton)
+            return true;
+        // If OpenSeadragon is active, let it handle gestures
+        if (this.osdViewer)
+            return false;
+        event.preventDefault();
+        event.stopPropagation();
+        // Handle pinch gesture (two fingers)
+        if (event.touches.length === 2) {
+            const touch1 = event.touches[0];
+            const touch2 = event.touches[1];
+            this.touchStartDistance = this.getDistance(touch1, touch2);
+            this.touchStartZoom = this.zoomLevel();
+            this.isPanning.set(false);
+            // store pinch midpoint (client coordinates) and current transform to keep the midpoint fixed while scaling
+            const midX = (touch1.clientX + touch2.clientX) / 2;
+            const midY = (touch1.clientY + touch2.clientY) / 2;
+            this.pinchStartClientX = midX;
+            this.pinchStartClientY = midY;
+            this.pinchStartTransformX = this.imageTransform().x;
+            this.pinchStartTransformY = this.imageTransform().y;
+        }
+        else if (event.touches.length === 1 && this.zoomLevel() > 1) {
+            // Handle pan gesture only if zoomed in
+            this.isPanning.set(true);
+            this.panStartX = event.touches[0].clientX;
+            this.panStartY = event.touches[0].clientY;
+            this.panStartTransformX = this.imageTransform().x;
+            this.panStartTransformY = this.imageTransform().y;
+        }
+        return false;
+    }
+    handleTouchMove(event) {
+        if (this.touchStartedOnButton)
+            return true;
+        // If OpenSeadragon is active, let it handle gestures
+        if (this.osdViewer)
+            return false;
+        event.preventDefault();
+        event.stopPropagation();
+        // Handle pinch zoom (two fingers)
+        if (event.touches.length === 2 && this.touchStartDistance > 0) {
+            const touch1 = event.touches[0];
+            const touch2 = event.touches[1];
+            const currentDistance = this.getDistance(touch1, touch2);
+            const scale = currentDistance / this.touchStartDistance;
+            const newZoom = Math.max(0.5, Math.min(5, this.touchStartZoom * scale));
+            // adjust transform so the pinch midpoint remains under the same screen point
+            const el = this.document.getElementById(this.id());
+            if (el) {
+                const rect = el.getBoundingClientRect();
+                // relative point inside the element (in element pixels) at start of pinch
+                const relX = (this.pinchStartClientX - rect.left - this.pinchStartTransformX) /
+                    this.touchStartZoom;
+                const relY = (this.pinchStartClientY - rect.top - this.pinchStartTransformY) /
+                    this.touchStartZoom;
+                const newTx = this.pinchStartClientX - rect.left - relX * newZoom;
+                const newTy = this.pinchStartClientY - rect.top - relY * newZoom;
+                this.imageTransform.set({ x: newTx, y: newTy });
+            }
+            this.zoomLevel.set(newZoom);
+        }
+        // Handle pan/drag (one finger while zoomed)
+        else if (event.touches.length === 1 &&
+            this.isPanning() &&
+            this.zoomLevel() > 1) {
+            const deltaX = event.touches[0].clientX - this.panStartX;
+            const deltaY = event.touches[0].clientY - this.panStartY;
+            this.imageTransform.set({
+                x: this.panStartTransformX + deltaX,
+                y: this.panStartTransformY + deltaY,
+            });
+        }
+        return false;
+    }
+    handleTouchEnd() {
+        this.touchStartDistance = 0;
+        this.touchStartZoom = 1;
+        this.isPanning.set(false);
+    }
+    handleMouseDown(event) {
+        if (this.zoomLevel() <= 1)
+            return false;
+        event.preventDefault();
+        this.isPanning.set(true);
+        this.panStartX = event.clientX;
+        this.panStartY = event.clientY;
+        this.panStartTransformX = this.imageTransform().x;
+        this.panStartTransformY = this.imageTransform().y;
+        return false;
+    }
+    handleMouseMove(event) {
+        if (!this.isPanning() || this.zoomLevel() <= 1)
+            return false;
+        event.preventDefault();
+        const deltaX = event.clientX - this.panStartX;
+        const deltaY = event.clientY - this.panStartY;
+        requestAnimationFrame(() => {
+            this.imageTransform.set({
+                x: this.panStartTransformX + deltaX,
+                y: this.panStartTransformY + deltaY,
+            });
+        });
+        return false;
+    }
+    handleMouseUp() {
+        this.isPanning.set(false);
+    }
+    handleWheel(event) {
+        // If OpenSeadragon is active, let it handle wheel events
+        if (this.osdViewer) {
+            event.preventDefault();
+            event.stopPropagation();
+            return false;
+        }
+        return false;
+    }
+    previousImage() {
+        if (this.canGoPrevious()) {
+            // start loading when navigating
+            this.startLoading();
+            this.fullscreenIndex.update((i) => i - 1);
+        }
+    }
+    nextImage() {
+        if (this.canGoNext()) {
+            // start loading when navigating
+            this.startLoading();
+            this.fullscreenIndex.update((i) => i + 1);
+        }
+    }
+    selectThumbnail(index) {
+        if (index === this.fullscreenIndex()) {
+            // same index — no navigation, but ensure loading is false
+            this.stopLoading();
+            return;
+        }
+        // start loading when selecting thumbnail
+        this.startLoading();
+        this.fullscreenIndex.set(index);
+    }
+    zoomIn() {
+        if (this.osdViewer) {
+            this.ngZone.runOutsideAngular(() => {
+                try {
+                    const viewport = this.osdViewer.viewport;
+                    viewport.zoomBy(1.2);
+                    viewport.applyConstraints();
+                    this.ngZone.run(() => {
+                        const homeZoom = viewport.getHomeZoom();
+                        const currentZoom = viewport.getZoom();
+                        this.zoomLevel.set(currentZoom / homeZoom);
+                    });
+                }
+                catch (e) {
+                    // Fallback to manual zoom
+                    this.ngZone.run(() => {
+                        this.zoomLevel.update((z) => Math.min(z + 0.5, 5));
+                    });
+                }
+            });
+            return;
+        }
+        this.zoomLevel.update((z) => Math.min(z + 0.5, 5));
+    }
+    zoomOut() {
+        if (this.osdViewer) {
+            this.ngZone.runOutsideAngular(() => {
+                try {
+                    const viewport = this.osdViewer.viewport;
+                    viewport.zoomBy(1 / 1.2);
+                    viewport.applyConstraints();
+                    this.ngZone.run(() => {
+                        const homeZoom = viewport.getHomeZoom();
+                        const currentZoom = viewport.getZoom();
+                        this.zoomLevel.set(currentZoom / homeZoom);
+                    });
+                }
+                catch (e) {
+                    // Fallback to manual zoom
+                    this.ngZone.run(() => {
+                        this.zoomLevel.update((z) => Math.max(z - 0.5, 0.5));
+                    });
+                }
+            });
+            return;
+        }
+        this.zoomLevel.update((z) => Math.max(z - 0.5, 0.5));
+    }
+    resetZoom() {
+        this.rotation.set(0);
+        if (this.osdViewer) {
+            this.ngZone.runOutsideAngular(() => {
+                try {
+                    const viewport = this.osdViewer.viewport;
+                    // First reset rotation, then go home - order matters!
+                    viewport.setRotation(0);
+                    viewport.applyConstraints();
+                    viewport.goHome(true);
+                    viewport.applyConstraints();
+                    this.ngZone.run(() => {
+                        this.zoomLevel.set(1); // Home = 100%
+                    });
+                }
+                catch (e) {
+                    // Fallback to manual reset
+                    this.ngZone.run(() => {
+                        this.zoomLevel.set(1);
+                        this.imageTransform.set({ x: 0, y: 0 });
+                    });
+                }
+            });
+            return;
+        }
+        this.zoomLevel.set(1);
+        this.imageTransform.set({ x: 0, y: 0 });
+    }
+    async downloadImage() {
+        const item = this.fullscreenItem();
+        if (!item?.image)
+            return;
+        const url = this.fileUrlService.get(item.image, 'noCache');
+        const filename = `${item.image.id || 'image'}.${item.image.extension || 'jpg'}`;
+        try {
+            const response = await fetch(url);
+            const blob = await response.blob();
+            const blobUrl = URL.createObjectURL(blob);
+            const link = this.document.createElement('a');
+            link.href = blobUrl;
+            link.download = filename;
+            link.click();
+            URL.revokeObjectURL(blobUrl);
+        }
+        catch (error) {
+            console.error('Failed to download image:', error);
+        }
+    }
+    async loadOsdImage(image) {
+        if (!this.osdViewer)
+            return;
+        const url = this.fileUrlService.get(image, 'noCache');
+        this.ngZone.runOutsideAngular(() => {
+            try {
+                // Close any existing image
+                try {
+                    this.osdViewer.close();
+                }
+                catch (e) {
+                    // Ignore errors
+                }
+                // Open the new image
+                this.osdViewer.open({
+                    type: 'image',
+                    url: url,
+                });
+            }
+            catch (error) {
+                console.error('Failed to load image in OpenSeadragon:', error);
+                this.ngZone.run(() => {
+                    this.stopLoading();
+                });
+            }
+        });
+    }
+    getDistance(touch1, touch2) {
+        const dx = touch1.clientX - touch2.clientX;
+        const dy = touch1.clientY - touch2.clientY;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: GalleryFullscreenBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.1.0", type: GalleryFullscreenBaseComponent, isStandalone: true, inputs: { items: { classPropertyName: "items", publicName: "items", isSignal: true, isRequired: false, transformFunction: null }, alt: { classPropertyName: "alt", publicName: "alt", isSignal: true, isRequired: false, transformFunction: null }, id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, selectedIndex: { classPropertyName: "selectedIndex", publicName: "selectedIndex", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { selectedIndex: "selectedIndexChange", closeChange: "closeChange" }, host: { listeners: { "document:keydown": "handleKeyboardEvent($event)", "mousedown": "handleMouseDown($event)", "mousemove": "handleMouseMove($event)", "mouseup": "handleMouseUp()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: GalleryFullscreenBaseComponent, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        '(document:keydown)': 'handleKeyboardEvent($event)',
+                        '(mousedown)': 'handleMouseDown($event)',
+                        '(mousemove)': 'handleMouseMove($event)',
+                        '(mouseup)': 'handleMouseUp()',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+
 class FooterComponent {
     constructor() {
         this.configsFacade = inject(ConfigsFacade);
@@ -2545,5 +3345,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ARTICLES_WIDGET_COMPONENTS_TOKEN, AppComponent, AuthStorageService, COMPONENTS, ClickOutsideDirective, ConfigsFacade, ConfigsService, ContrastService, CrudBaseService, DIRECTIVES, DictionaryService, FileUrlService, FiltersBaseComponent, FiltersContext, FooterComponent, GameType, GlobalService, HeaderComponent, HomeComponent, HoverDirective, ImageBox, ListMode, MasonryGridComponent, MenuComponent, MetaService, ModalContainerComponent, ModalRef, ModalService, NotFoundComponent, PageComponent, PageStaticComponent, QueryFilterService, SEARCH_CONFIG_TOKEN, SERVICES, ScrollTopComponent, ScrollableDirective, SearchService, SeoService, SettingsService, SharedConfig, SharedModule, StyleService, TRANSLATE_DATA_PL, TranslationService, WcagService, WidgetBaseComponent, WidgetComponent, WidgetTextComponent, authenticationGuard, environment, getSearchFilterQuery, setTranslationsAndLang, unauthorizedGuard };
+export { ARTICLES_WIDGET_COMPONENTS_TOKEN, AppComponent, AuthStorageService, COMPONENTS, ClickOutsideDirective, ConfigsFacade, ConfigsService, ContrastService, CrudBaseService, DIRECTIVES, DictionaryService, FileUrlService, FiltersBaseComponent, FiltersContext, FooterComponent, GalleryFullscreenBaseComponent, GameType, GlobalService, HeaderComponent, HomeComponent, HoverDirective, ImageBox, ListMode, MasonryGridComponent, MediaTabBaseComponent, MenuComponent, MetaService, ModalContainerComponent, ModalRef, ModalService, NotFoundComponent, PageComponent, PageStaticComponent, QueryFilterService, SEARCH_CONFIG_TOKEN, SERVICES, ScrollTopComponent, ScrollableDirective, SearchBaseComponent, SearchService, SeoService, SettingsService, SharedConfig, SharedModule, SliderBaseComponent, StyleService, TRANSLATE_DATA_PL, TranslationService, WcagService, WidgetBaseComponent, WidgetComponent, WidgetTextComponent, authenticationGuard, environment, getSearchFilterQuery, setTranslationsAndLang, unauthorizedGuard };
 //# sourceMappingURL=smartsoft001-mobilems-angular.mjs.map