@npm9912/v-map 0.1.0

package/dist/collection/map-provider/ol/CustomGeoTiff.js

@@ -0,0 +1,145 @@
+import proj4 from "proj4";
+import { error, warn } from "../../utils/logger";
+import GeoTIFF from "ol/source/GeoTIFF";
+import geokeysToProj4 from "geotiff-geokeys-to-proj4";
+import { get as getProjection } from "ol/proj";
+import { register } from "ol/proj/proj4";
+// let projectionHelpersPromise: Promise<ProjectionHelpers> | null = null;
+// async function loadProjectionHelpers(): Promise<ProjectionHelpers> {
+//   if (!projectionHelpersPromise) {
+//     projectionHelpersPromise = Promise.all([
+//       import('ol/proj'),
+//       import('ol/proj/proj4'),
+//     ]).then(([projModule, proj4Module]) => ({
+//       getProjection: getProjection,
+//       register: register,
+//     }));
+//   }
+//   return projectionHelpersPromise;
+// }
+export async function createCustomGeoTiff(options) {
+    /**
+     * Gibt die GeoKeys eines GeoTIFF-Bildes zurück.
+     * @param image Das GeoTIFF-Bild.
+     * @returns Die GeoKeys oder `null`, falls keine vorhanden sind.
+     */
+    function getGeoKeys(image) {
+        if (typeof image.getGeoKeys === 'function') {
+            return image.getGeoKeys() || null;
+        }
+        return image.geoKeys || null;
+    }
+    return class CustomGeoTiff extends GeoTIFF {
+        geoKeys_ = null;
+        constructor() {
+            super(options);
+        }
+        /**
+         * Gibt die GeoKeys der ersten Quelle zurück.
+         * @returns Ein Promise, das die GeoKeys oder `null` zurückgibt.
+         */
+        async getGeoKeys() {
+            if (this.geoKeys_ !== null) {
+                return this.geoKeys_;
+            }
+            await this.getView();
+            //const sources = this.sources_;
+            // @ts-expect-error Zugriff auf private Eigenschaft `sourceImagery_`
+            const sources = this.sourceImagery_;
+            if (sources && sources.length > 0) {
+                this.determineGeoKeys(sources);
+            }
+            return this.geoKeys_;
+        }
+        /**
+         * Bestimmt die GeoKeys aus den Quellen.
+         * @param sources Die Quellen des GeoTIFFs.
+         */
+        determineGeoKeys(sources) {
+            if (!sources || sources.length === 0) {
+                return;
+            }
+            const firstSource = sources[0];
+            for (let i = firstSource.length - 1; i >= 0; --i) {
+                const image = firstSource[i];
+                const geoKeys = getGeoKeys(image);
+                if (geoKeys) {
+                    this.geoKeys_ = geoKeys;
+                    break;
+                }
+            }
+        }
+        /**
+         * Gibt die Proj4-Projektionsparameter basierend auf den GeoKeys zurück.
+         * @returns Ein Promise, das die Proj4-Projektionsparameter oder `null` zurückgibt.
+         */
+        async getProjectionParameters() {
+            const geoKeys = await this.getGeoKeys();
+            if (!geoKeys) {
+                return null;
+            }
+            return geokeysToProj4.toProj4(geoKeys);
+        }
+        /**
+         * Gibt die Proj4-Projektion als String basierend auf den GeoKeys zurück.
+         * @returns Ein Promise, das die Proj4-Projektion als String oder `null` zurückgibt.
+         */
+        async getProj4String() {
+            const params = await this.getProjectionParameters();
+            if (!params) {
+                return null;
+            }
+            // Proj4-String aus den Parametern erstellen
+            return params.proj4 || null;
+        }
+        //   /**
+        //    * Registriert die Proj4-Projektion in OpenLayers, falls sie noch nicht existiert.
+        //    * @param proj4String Die Proj4-Projektion als String.
+        //    * @param code Der Code für die Projektion (z. B. 'CUSTOM:1234').
+        //    * @returns Die OpenLayers-Projektion oder `null`, falls die Registrierung fehlschlägt.
+        //    */
+        //   public async registerProjectionIfNeeded(
+        //     proj4String: string,
+        //     code: string,
+        //   ): Promise<import('ol/proj').Projection | null> {
+        //     try {
+        //       const existingProjection = getProjection(code);
+        //       if (existingProjection) {
+        //         return existingProjection;
+        //       }
+        //       proj4.defs(code, proj4String);
+        //       register(proj4);
+        //       return getProjection(code);
+        //     } catch (err) {
+        //       error('Fehler bei der Registrierung der Projektion:', err);
+        //       return null;
+        //     }
+        //   }
+        /**
+         * Registriert die Proj4-Projektion in OpenLayers, falls sie noch nicht existiert.
+         * @returns Die OpenLayers-Projektion oder `null`, falls die Registrierung fehlschlägt.
+         */
+        async registerProjectionIfNeeded() {
+            try {
+                //const { getProjection, register } = await loadProjectionHelpers();
+                const proj4String = await this.getProj4String();
+                const code = this.getProjection()?.getCode();
+                const existingProjection = getProjection(code);
+                if (existingProjection) {
+                    return existingProjection;
+                }
+                if (proj4String === null) {
+                    warn(`Can not get proj string for code: ${code}`);
+                    return null;
+                }
+                proj4.defs(code, proj4String);
+                register(proj4);
+                return getProjection(code);
+            }
+            catch (err) {
+                error('Fehler bei der Registrierung der Projektion:', err);
+                return null;
+            }
+        }
+    };
+}

package/dist/collection/map-provider/ol/openlayers-helper.js

@@ -0,0 +1,26 @@
+import { OL_VERSION } from "../../lib/versions.gen";
+/** CSS in ShadowRoot injizieren – ohne '?inline', kompatibel zu Stencil/Rollup */
+export async function injectOlCss(shadowRoot) {
+    if (!shadowRoot)
+        return;
+    const id = 'ol-css-sheet';
+    // Doppeltes Einfügen vermeiden
+    if (shadowRoot.querySelector(`style[data-id="${id}"]`))
+        return;
+    const url = `https://cdn.jsdelivr.net/npm/ol@${OL_VERSION}/ol.css`;
+    const css = await (await fetch(url)).text();
+    if ('adoptedStyleSheets' in Document.prototype) {
+        const sheet = new CSSStyleSheet();
+        await sheet.replace(css);
+        shadowRoot.adoptedStyleSheets = [
+            ...(shadowRoot.adoptedStyleSheets ?? []),
+            sheet,
+        ];
+    }
+    else {
+        const style = document.createElement('style');
+        style.setAttribute('data-id', id);
+        style.textContent = css;
+        shadowRoot.appendChild(style);
+    }
+}