@kispace-io/gs-lib 1.1.8 → 1.2.0

package/dist/index.js

@@ -1,26 +1,26 @@
-const byteToHex = [];
+const byteToHex$1 = [];
 for (let i5 = 0; i5 < 256; ++i5) {
-  byteToHex.push((i5 + 256).toString(16).slice(1));
+  byteToHex$1.push((i5 + 256).toString(16).slice(1));
 }
-function unsafeStringify(arr, offset2 = 0) {
-  return (byteToHex[arr[offset2 + 0]] + byteToHex[arr[offset2 + 1]] + byteToHex[arr[offset2 + 2]] + byteToHex[arr[offset2 + 3]] + "-" + byteToHex[arr[offset2 + 4]] + byteToHex[arr[offset2 + 5]] + "-" + byteToHex[arr[offset2 + 6]] + byteToHex[arr[offset2 + 7]] + "-" + byteToHex[arr[offset2 + 8]] + byteToHex[arr[offset2 + 9]] + "-" + byteToHex[arr[offset2 + 10]] + byteToHex[arr[offset2 + 11]] + byteToHex[arr[offset2 + 12]] + byteToHex[arr[offset2 + 13]] + byteToHex[arr[offset2 + 14]] + byteToHex[arr[offset2 + 15]]).toLowerCase();
+function unsafeStringify$1(arr, offset2 = 0) {
+  return (byteToHex$1[arr[offset2 + 0]] + byteToHex$1[arr[offset2 + 1]] + byteToHex$1[arr[offset2 + 2]] + byteToHex$1[arr[offset2 + 3]] + "-" + byteToHex$1[arr[offset2 + 4]] + byteToHex$1[arr[offset2 + 5]] + "-" + byteToHex$1[arr[offset2 + 6]] + byteToHex$1[arr[offset2 + 7]] + "-" + byteToHex$1[arr[offset2 + 8]] + byteToHex$1[arr[offset2 + 9]] + "-" + byteToHex$1[arr[offset2 + 10]] + byteToHex$1[arr[offset2 + 11]] + byteToHex$1[arr[offset2 + 12]] + byteToHex$1[arr[offset2 + 13]] + byteToHex$1[arr[offset2 + 14]] + byteToHex$1[arr[offset2 + 15]]).toLowerCase();
 }
-let getRandomValues;
-const rnds8 = new Uint8Array(16);
-function rng() {
-  if (!getRandomValues) {
+let getRandomValues$1;
+const rnds8$1 = new Uint8Array(16);
+function rng$1() {
+  if (!getRandomValues$1) {
     if (typeof crypto === "undefined" || !crypto.getRandomValues) {
       throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
     }
-    getRandomValues = crypto.getRandomValues.bind(crypto);
+    getRandomValues$1 = crypto.getRandomValues.bind(crypto);
   }
-  return getRandomValues(rnds8);
+  return getRandomValues$1(rnds8$1);
 }
-const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-const native = { randomUUID };
+const randomUUID$1 = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const native$1 = { randomUUID: randomUUID$1 };
 function _v4(options, buf, offset2) {
   options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
+  const rnds = options.random ?? options.rng?.() ?? rng$1();
   if (rnds.length < 16) {
     throw new Error("Random bytes length must be >= 16");
   }
@@ -36,11 +36,11 @@ function _v4(options, buf, offset2) {
     }
     return buf;
   }
-  return unsafeStringify(rnds);
+  return unsafeStringify$1(rnds);
 }
-function v4(options, buf, offset2) {
-  if (native.randomUUID && !buf && !options) {
-    return native.randomUUID();
+function v4$1(options, buf, offset2) {
+  if (native$1.randomUUID && !buf && !options) {
+    return native$1.randomUUID();
   }
   return _v4(options, buf, offset2);
 }
@@ -60,7 +60,7 @@ const KEY_EVENT_SUBSCRIPTIONS = "_eventSubscriptions";
 const LAYER_GEOCODED_MARKERS = "geocoded-markers";
 function ensureUuid(obj) {
   if (!obj.uuid) {
-    obj.uuid = v4();
+    obj.uuid = v4$1();
   }
   return obj;
 }
@@ -268,6 +268,333 @@ const DEFAULT_GSMAP = ensureUuid({
   styles: { ...DEFAULT_STYLES },
   styleRules: [...DEFAULT_STYLE_RULES]
 });
+function findLayerByUuid(gsMap, uuid) {
+  return gsMap.layers.find((layer2) => layer2.uuid === uuid);
+}
+function findLayerIndexByUuid(gsMap, uuid) {
+  return gsMap.layers.findIndex((layer2) => layer2.uuid === uuid);
+}
+function findControlByUuid(gsMap, uuid) {
+  return gsMap.controls.find((control) => control.uuid === uuid);
+}
+function findControlIndexByUuid(gsMap, uuid) {
+  return gsMap.controls.findIndex((control) => control.uuid === uuid);
+}
+function findOverlayByUuid(gsMap, uuid) {
+  return gsMap.overlays.find((overlay) => overlay.uuid === uuid);
+}
+function findOverlayIndexByUuid(gsMap, uuid) {
+  return gsMap.overlays.findIndex((overlay) => overlay.uuid === uuid);
+}
+const createProxy = (operations) => {
+  return new Proxy({}, {
+    get: (_2, prop) => {
+      return async (...args) => {
+        for (const operation of operations) {
+          await operation[prop](...args);
+        }
+      };
+    }
+  });
+};
+function generateAppJs(vars) {
+  const allScripts = [...vars.gsMap.controls || [], ...vars.gsMap.overlays || []];
+  const scriptPaths = allScripts.map((script) => script.src).filter((src) => src);
+  const scriptImports = scriptPaths.map((src, index) => {
+    const escapedSrc = src.replace(/`/g, "\\`").replace(/\$/g, "\\$");
+    return `import script${index} from '${escapedSrc}'`;
+  });
+  const modulesMap = scriptPaths.map((src, index) => {
+    const escapedSrc = JSON.stringify(src);
+    return `${escapedSrc}: script${index}`;
+  }).join(",\n        ");
+  return `
+import {gsLib} from "${vars.gsLibPath}"
+import "./gs-lib/gs-lib.css"
+
+${scriptImports.join("\n")}
+
+export const renderMap = (mapContainerSelector) => {
+    const modules = {
+        ${modulesMap}
+    }
+    return gsLib({
+        containerSelector: mapContainerSelector,
+        gsMap: ${JSON.stringify(vars.gsMap)},
+        mapOptions: {
+            controls: {zoom: false, attribution: false}
+        },
+        env: ${JSON.stringify(vars.env || {})},
+        modules: modules
+    })
+}
+`;
+}
+function generatePrecacheManifest(assets) {
+  return JSON.stringify(assets, null, 2);
+}
+function processServiceWorker(content, precacheManifest) {
+  if (precacheManifest) {
+    const manifestJson = generatePrecacheManifest(precacheManifest);
+    if (content.includes("self.__WB_MANIFEST")) {
+      return content.replace(
+        "self.__WB_MANIFEST || []",
+        `${manifestJson}`
+      );
+    } else {
+      return content.replace(
+        /workbox\.precaching\.precacheAndRoute\(/,
+        `self.__WB_MANIFEST = ${manifestJson};
+workbox.precaching.precacheAndRoute(`
+      );
+    }
+  }
+  return content;
+}
+function processManifest(content, title, version) {
+  const manifest = JSON.parse(content);
+  manifest.name = title;
+  manifest.short_name = title;
+  manifest.description = title;
+  manifest.version = version;
+  return JSON.stringify(manifest, null, 2);
+}
+function processHtml(content, title, appJsFilename, appCssFilename) {
+  let processed = content.replace(/\$TITLE/g, title);
+  if (appJsFilename) {
+    processed = processed.replace(/\.\/app\.js/g, `./${appJsFilename}`);
+  }
+  if (appCssFilename) {
+    processed = processed.replace(/href=["']app\.css["']/g, `href="${appCssFilename}"`);
+  }
+  return processed;
+}
+async function bundleApp(entryPointPath, outputDir, gsLibPath, fileSys, resolvePlugin, esbuildInstance, progress, currentStep, totalSteps) {
+  const updateProgress = (message) => {
+    if (progress) {
+      if (currentStep !== void 0) {
+        progress(++currentStep.value, message, totalSteps);
+      } else {
+        progress(0, message, totalSteps);
+      }
+    }
+  };
+  updateProgress("Bundling and minifying code...");
+  const result = await esbuildInstance.build({
+    entryPoints: [entryPointPath],
+    bundle: true,
+    outdir: outputDir,
+    format: "esm",
+    minify: true,
+    plugins: [resolvePlugin],
+    entryNames: "[name]-[hash]",
+    // Runtime dependencies (lit, webawesome) are bundled with gs-lib
+    external: [],
+    // Bundle all dependencies
+    packages: "bundle",
+    write: false,
+    // Don't write to disk, we'll handle it
+    metafile: true
+    // Generate metafile to get output information
+  });
+  updateProgress("Saving bundled output...");
+  if (!result.outputFiles || result.outputFiles.length === 0) {
+    throw new Error("No output files generated by esbuild");
+  }
+  let mainOutputFile = null;
+  let cssOutputFile = null;
+  if (result.metafile && result.metafile.outputs) {
+    const entryName = "app";
+    for (const [outputPath, output] of Object.entries(result.metafile.outputs)) {
+      if (output && typeof output === "object" && "entryPoint" in output) {
+        if (outputPath.includes(entryName) && outputPath.endsWith(".js")) {
+          mainOutputFile = outputPath;
+        } else if (outputPath.endsWith(".css")) {
+          cssOutputFile = outputPath;
+        }
+      }
+    }
+  }
+  const extractFilename = (filePath) => {
+    const lastSlash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+    return lastSlash >= 0 ? filePath.substring(lastSlash + 1) : filePath;
+  };
+  for (const file of result.outputFiles) {
+    let filePath = file.path || "";
+    let relativePath;
+    let filename;
+    if (filePath.startsWith("/") || filePath.length > 2 && filePath[1] === ":") {
+      filename = extractFilename(filePath);
+      relativePath = `${outputDir}/${filename}`;
+    } else {
+      filename = extractFilename(filePath);
+      relativePath = filePath.startsWith(outputDir) ? filePath : `${outputDir}/${filePath}`;
+    }
+    await fileSys.writeFile(relativePath, file.contents);
+    if (!mainOutputFile && filename.includes("app-") && filename.endsWith(".js")) {
+      mainOutputFile = filename;
+    }
+    if (!cssOutputFile && filename.includes("app-") && filename.endsWith(".css")) {
+      cssOutputFile = filename;
+    }
+  }
+  if (!mainOutputFile) {
+    throw new Error("Could not find main output file");
+  }
+  return {
+    js: extractFilename(mainOutputFile),
+    css: cssOutputFile ? extractFilename(cssOutputFile) : null
+  };
+}
+function createFileSystemGsLibCopier(fs2, gsLibPackagePath) {
+  const copyFile = async (srcPath, destPath, asText, processor) => {
+    const fullSrcPath = `${gsLibPackagePath}/${srcPath}`;
+    let content = await fs2.readFile(fullSrcPath);
+    if (asText) {
+      if (content instanceof Uint8Array) {
+        content = new TextDecoder().decode(content);
+      } else {
+        content = content;
+      }
+      if (processor) {
+        content = await processor(content);
+      }
+    }
+    await fs2.writeFile(destPath, content);
+  };
+  return {
+    async copyTextFile(srcPath, destPath, processor) {
+      await copyFile(srcPath, destPath, true, processor);
+    },
+    async copyBinaryFile(srcPath, destPath) {
+      await copyFile(srcPath, destPath, false);
+    }
+  };
+}
+async function buildMap(options, fs2, resolvePlugin, esbuildInstance, config = {}, progress) {
+  const {
+    outputDir = "dist",
+    buildDir = "__build",
+    gsLibPath = `${buildDir}/gs-lib/index.js`,
+    gsLibPackagePath,
+    gsLibCopier: providedGsLibCopier,
+    cleanBeforeBuild = true,
+    cleanAfterBuild = true,
+    copyAssets
+  } = config;
+  const gsLibCopier = providedGsLibCopier || (gsLibPackagePath ? createFileSystemGsLibCopier(fs2, gsLibPackagePath) : null);
+  if (!gsLibCopier) {
+    throw new Error("Either gsLibCopier or gsLibPackagePath must be provided");
+  }
+  const buildGsLibPath = gsLibPath;
+  let step = config.startingStep ?? 0;
+  const totalSteps = config.totalSteps;
+  const updateProgress = (message) => {
+    if (progress) progress(++step, message, totalSteps);
+  };
+  if (cleanBeforeBuild) {
+    updateProgress("Cleaning build directories...");
+    const cleanupPromises = [];
+    if (fs2.deleteDir) {
+      cleanupPromises.push(
+        fs2.deleteDir(buildDir).catch(() => {
+        }),
+        // Ignore errors if directory doesn't exist
+        fs2.deleteDir(outputDir).catch(() => {
+        })
+      );
+    } else {
+      try {
+        const nodeFs = await Promise.resolve().then(() => __viteBrowserExternal);
+        const path = await Promise.resolve().then(() => __viteBrowserExternal);
+        const projectRoot = process.cwd();
+        cleanupPromises.push(
+          nodeFs.rm(path.resolve(projectRoot, buildDir), { recursive: true, force: true }).catch(() => {
+          }),
+          nodeFs.rm(path.resolve(projectRoot, outputDir), { recursive: true, force: true }).catch(() => {
+          })
+        );
+      } catch {
+      }
+    }
+    await Promise.all(cleanupPromises);
+  }
+  updateProgress("Preparing build directories...");
+  await Promise.all([
+    fs2.ensureDir(`${outputDir}/assets/icons/`),
+    fs2.ensureDir(`${buildDir}/gs-lib/`)
+  ]);
+  updateProgress("Copying gs-lib package...");
+  await Promise.all([
+    gsLibCopier.copyTextFile("dist/index.js", `${buildDir}/gs-lib/index.js`),
+    gsLibCopier.copyTextFile("dist/gs-lib.css", `${buildDir}/gs-lib/gs-lib.css`)
+  ]);
+  updateProgress("Copying PWA core files...");
+  await gsLibCopier.copyTextFile("public/pwa/staticwebapp.config.json", `${outputDir}/staticwebapp.config.json`);
+  updateProgress("Creating manifest file...");
+  await gsLibCopier.copyTextFile("public/pwa/manifest.json", `${outputDir}/manifest.json`, (content) => processManifest(content, options.title, options.version));
+  updateProgress("Copying PWA icons...");
+  const iconFiles = [
+    "24x24.png",
+    "48x48.png",
+    "192x192.png",
+    "512x512.png",
+    "icon_24.png",
+    "icon_48.png",
+    "icon_192.png",
+    "icon_512.png"
+  ];
+  await Promise.all(iconFiles.map(
+    (icon) => gsLibCopier.copyBinaryFile(`public/pwa/assets/icons/${icon}`, `${outputDir}/assets/icons/${icon}`)
+  ));
+  if (copyAssets) {
+    updateProgress("Copying workspace assets...");
+    await copyAssets(fs2, outputDir, progress);
+  }
+  updateProgress("Generating application code...");
+  const entryPointContent = generateAppJs({
+    gsMap: options.gsMap,
+    gsLibPath: buildGsLibPath,
+    env: { ...options.env, BUILD_TIME: /* @__PURE__ */ new Date() }
+  });
+  await fs2.writeFile(`${buildDir}/app.js`, entryPointContent);
+  const stepRef = { value: step };
+  const bundleResult = await bundleApp(`${buildDir}/app.js`, outputDir, buildGsLibPath, fs2, resolvePlugin, esbuildInstance, progress, stepRef, totalSteps);
+  step = stepRef.value;
+  const appJsFilename = bundleResult.js;
+  const appCssFilename = bundleResult.css;
+  updateProgress("Generating HTML file...");
+  await gsLibCopier.copyTextFile("public/index.html", `${outputDir}/index.html`, (content) => processHtml(content, options.title, appJsFilename, appCssFilename || void 0));
+  const precacheManifest = [
+    { url: `/${appJsFilename}`, revision: null },
+    // Hashed filename handles versioning
+    ...appCssFilename ? [{ url: `/${appCssFilename}`, revision: null }] : [],
+    // Hashed CSS filename handles versioning
+    ...iconFiles.map((icon) => ({ url: `/assets/icons/${icon}`, revision: null }))
+    // Workbox will check file content
+  ];
+  updateProgress("Processing service worker...");
+  await gsLibCopier.copyTextFile(
+    "public/pwa/sw.js",
+    `${outputDir}/sw.js`,
+    (content) => processServiceWorker(content, precacheManifest)
+  );
+  if (cleanAfterBuild) {
+    updateProgress("Cleaning up temporary files...");
+    if (fs2.deleteDir) {
+      await fs2.deleteDir(buildDir);
+    } else {
+      try {
+        const nodeFs = await Promise.resolve().then(() => __viteBrowserExternal);
+        const path = await Promise.resolve().then(() => __viteBrowserExternal);
+        const fullPath = path.resolve(process.cwd(), buildDir);
+        await nodeFs.rm(fullPath, { recursive: true, force: true });
+      } catch (error2) {
+      }
+    }
+  }
+  updateProgress("Build completed!");
+}
 const CollectionEventType = {
   /**
    * Triggered when an item is added to the collection.
@@ -99027,7 +99354,7 @@ const importSrc = async (adapter, src, importer) => {
         ol,
         env: olMap.get(KEY_ENV) || {},
         utils: {
-          uuid: v4
+          uuid: v4$1
         },
         asset: (path) => {
           return rtUtils.resolveUrl(`assets/${path}`);
@@ -99176,7 +99503,7 @@ const cleanupEventSubscriptions = (olMap) => {
     olMap.set(KEY_EVENT_SUBSCRIPTIONS, []);
   }
 };
-const toOlMap = async (gsMap, options, env, importer) => {
+const toOlMap = async (gsMap, options, env, importer, target) => {
   const olMap = withState(gsMap, new Map$1(options));
   olMap.set(KEY_ENV, env);
   olMap.setView(new View({
@@ -99188,6 +99515,9 @@ const toOlMap = async (gsMap, options, env, importer) => {
     const olLayer = toOlLayer(layer2);
     olMap.addLayer(olLayer);
   }
+  if (target) {
+    olMap.setTarget(target);
+  }
   for (const overlay of gsMap.overlays || []) {
     const olOverlay = toOlOverlay(overlay);
     olMap.addOverlay(olOverlay);
@@ -99259,7 +99589,7 @@ function toGsFeature(feature) {
     geometry: toGsGeometry(feature.getGeometry())
   });
 }
-const gsLib = async (options) => {
+const olLib = async (options) => {
   const mapOptions = {
     interactions: defaults({ keyboard: false }),
     controls: defaults$1(options.mapOptions?.controls)
@@ -99277,309 +99607,572 @@ const gsLib = async (options) => {
       throw new Error(`Module not found: ${src}`);
     };
   }
-  const olMap = await toOlMap(options.gsMap, mapOptions, options.env, importer);
   const target = typeof options.containerSelector === "string" ? document.querySelector(options.containerSelector) : options.containerSelector;
-  olMap.setTarget(target);
+  const olMap = await toOlMap(options.gsMap, mapOptions, options.env, importer, target);
   return olMap;
 };
-function generateAppJs(vars) {
-  const allScripts = [...vars.gsMap.controls || [], ...vars.gsMap.overlays || []];
-  const scriptPaths = allScripts.map((script) => script.src).filter((src) => src);
-  const scriptImports = scriptPaths.map((src, index) => {
-    const escapedSrc = src.replace(/`/g, "\\`").replace(/\$/g, "\\$");
-    return `import script${index} from '${escapedSrc}'`;
-  });
-  const modulesMap = scriptPaths.map((src, index) => {
-    const escapedSrc = JSON.stringify(src);
-    return `${escapedSrc}: script${index}`;
-  }).join(",\n        ");
-  return `
-import {gsLib} from "${vars.gsLibPath}"
-import "./gs-lib/gs-lib.css"
-
-${scriptImports.join("\n")}
-
-export const renderMap = (mapContainerSelector) => {
-    const modules = {
-        ${modulesMap}
-    }
-    return gsLib({
-        containerSelector: mapContainerSelector,
-        gsMap: ${JSON.stringify(vars.gsMap)},
-        mapOptions: {
-            controls: {zoom: false, attribution: false}
-        },
-        env: ${JSON.stringify(vars.env || {})},
-        modules: modules
-    })
-}
-`;
+const byteToHex = [];
+for (let i5 = 0; i5 < 256; ++i5) {
+  byteToHex.push((i5 + 256).toString(16).slice(1));
 }
-function generatePrecacheManifest(assets) {
-  return JSON.stringify(assets, null, 2);
+function unsafeStringify(arr, offset2 = 0) {
+  return (byteToHex[arr[offset2 + 0]] + byteToHex[arr[offset2 + 1]] + byteToHex[arr[offset2 + 2]] + byteToHex[arr[offset2 + 3]] + "-" + byteToHex[arr[offset2 + 4]] + byteToHex[arr[offset2 + 5]] + "-" + byteToHex[arr[offset2 + 6]] + byteToHex[arr[offset2 + 7]] + "-" + byteToHex[arr[offset2 + 8]] + byteToHex[arr[offset2 + 9]] + "-" + byteToHex[arr[offset2 + 10]] + byteToHex[arr[offset2 + 11]] + byteToHex[arr[offset2 + 12]] + byteToHex[arr[offset2 + 13]] + byteToHex[arr[offset2 + 14]] + byteToHex[arr[offset2 + 15]]).toLowerCase();
 }
-function processServiceWorker(content, precacheManifest) {
-  if (precacheManifest) {
-    const manifestJson = generatePrecacheManifest(precacheManifest);
-    if (content.includes("self.__WB_MANIFEST")) {
-      return content.replace(
-        "self.__WB_MANIFEST || []",
-        `${manifestJson}`
-      );
-    } else {
-      return content.replace(
-        /workbox\.precaching\.precacheAndRoute\(/,
-        `self.__WB_MANIFEST = ${manifestJson};
-workbox.precaching.precacheAndRoute(`
-      );
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
     }
+    getRandomValues = crypto.getRandomValues.bind(crypto);
   }
-  return content;
-}
-function processManifest(content, title, version) {
-  const manifest = JSON.parse(content);
-  manifest.name = title;
-  manifest.short_name = title;
-  manifest.description = title;
-  manifest.version = version;
-  return JSON.stringify(manifest, null, 2);
+  return getRandomValues(rnds8);
 }
-function processHtml(content, title, appJsFilename, appCssFilename) {
-  let processed = content.replace(/\$TITLE/g, title);
-  if (appJsFilename) {
-    processed = processed.replace(/\.\/app\.js/g, `./${appJsFilename}`);
+const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const native = { randomUUID };
+function v4(options, buf, offset2) {
+  if (native.randomUUID && true && !options) {
+    return native.randomUUID();
   }
-  if (appCssFilename) {
-    processed = processed.replace(/href=["']app\.css["']/g, `href="${appCssFilename}"`);
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
   }
-  return processed;
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  return unsafeStringify(rnds);
 }
-async function bundleApp(entryPointPath, outputDir, gsLibPath, fileSys, resolvePlugin, esbuildInstance, progress, currentStep, totalSteps) {
-  const updateProgress = (message) => {
-    if (progress) {
-      if (currentStep !== void 0) {
-        progress(++currentStep.value, message, totalSteps);
-      } else {
-        progress(0, message, totalSteps);
-      }
-    }
-  };
-  updateProgress("Bundling and minifying code...");
-  const result = await esbuildInstance.build({
-    entryPoints: [entryPointPath],
-    bundle: true,
-    outdir: outputDir,
-    format: "esm",
-    minify: true,
-    plugins: [resolvePlugin],
-    entryNames: "[name]-[hash]",
-    // Runtime dependencies (lit, webawesome) are bundled with gs-lib
-    external: [],
-    // Bundle all dependencies
-    packages: "bundle",
-    write: false,
-    // Don't write to disk, we'll handle it
-    metafile: true
-    // Generate metafile to get output information
+function getFeatureStyleData(feature) {
+  const geometry = feature.getGeometry();
+  return ensureUuid({
+    geometry: ensureUuid({
+      type: geometry.getType(),
+      coordinates: []
+      // Not needed for style rules
+    }),
+    state: feature.get(KEY_STATE)
   });
-  updateProgress("Saving bundled output...");
-  if (!result.outputFiles || result.outputFiles.length === 0) {
-    throw new Error("No output files generated by esbuild");
+}
+class OpenLayersMapRenderer {
+  constructor(gsMap, env) {
+    this.isDestroyed = false;
+    this.styleCache = /* @__PURE__ */ new Map();
+    this.gsMap = gsMap;
+    this.env = env;
   }
-  let mainOutputFile = null;
-  let cssOutputFile = null;
-  if (result.metafile && result.metafile.outputs) {
-    const entryName = "app";
-    for (const [outputPath, output] of Object.entries(result.metafile.outputs)) {
-      if (output && typeof output === "object" && "entryPoint" in output) {
-        if (outputPath.includes(entryName) && outputPath.endsWith(".js")) {
-          mainOutputFile = outputPath;
-        } else if (outputPath.endsWith(".css")) {
-          cssOutputFile = outputPath;
+  async reattached() {
+  }
+  async render(container) {
+    try {
+      this.olMap = await olLib({
+        containerSelector: container,
+        gsMap: this.gsMap,
+        env: this.env,
+        mapOptions: {
+          controls: { zoom: false, attribution: false }
         }
+      });
+      this.operations = new OpenLayersMapOperations(this.olMap, this);
+      this.applyStylesToLayers();
+      this.olMap.once("rendercomplete", () => {
+        this.setupEventListeners();
+      });
+    } catch (error2) {
+      console.error("Failed to render map:", error2);
+      throw error2;
+    }
+  }
+  applyStylesToLayers() {
+    if (!this.olMap) return;
+    const layers = this.olMap.getLayers().getArray();
+    layers.forEach((layer$12) => {
+      if (layer$12 instanceof VectorLayer) {
+        this.applyStyleToVectorLayer(layer$12);
       }
+    });
+  }
+  applyStyleToVectorLayer(layer2) {
+    const layerName = layer2.get(KEY_NAME);
+    const styleFunction = (feature) => {
+      if (!(feature instanceof Feature)) {
+        return void 0;
+      }
+      const featureStyleData = getFeatureStyleData(feature);
+      const styleRules = this.gsMap.styleRules;
+      const stylesMap = this.gsMap.styles;
+      if (styleRules && stylesMap) {
+        const gsStyle = getStyleForFeature(featureStyleData, styleRules, stylesMap, layerName);
+        if (gsStyle && gsStyle.id) {
+          let olStyle = this.styleCache.get(gsStyle.id);
+          if (!olStyle) {
+            olStyle = toOlStyle(gsStyle);
+            this.styleCache.set(gsStyle.id, olStyle);
+          }
+          return olStyle;
+        } else if (gsStyle) {
+          return toOlStyle(gsStyle);
+        }
+      }
+      return void 0;
+    };
+    layer2.setStyle(styleFunction);
+  }
+  clearStyleCache() {
+    this.styleCache.clear();
+  }
+  async modelToUI(updatedGsMap) {
+    if (!this.olMap) {
+      throw new Error("Map not initialized");
+    }
+    if (updatedGsMap) {
+      this.gsMap = updatedGsMap;
+    }
+    this.clearStyleCache();
+    const target = this.olMap.getTarget();
+    if (!target || typeof target === "string") {
+      throw new Error("Map container not found or invalid");
     }
+    this.destroy();
+    target.innerHTML = "";
+    this.isDestroyed = false;
+    await this.render(target);
   }
-  const path = await Promise.resolve().then(() => __viteBrowserExternal);
-  for (const file of result.outputFiles) {
-    let filePath = file.path || "";
-    let relativePath;
-    let filename;
-    if (filePath.startsWith("/") || filePath.length > 2 && filePath[1] === ":") {
-      filename = path.basename(filePath);
-      relativePath = `${outputDir}/${filename}`;
-    } else {
-      filename = path.basename(filePath);
-      relativePath = filePath.startsWith(outputDir) ? filePath : `${outputDir}/${filePath}`;
+  getOperations() {
+    if (!this.operations) {
+      throw new Error("Operations not available - map not rendered yet");
     }
-    await fileSys.writeFile(relativePath, file.contents);
-    if (!mainOutputFile && filename.includes("app-") && filename.endsWith(".js")) {
-      mainOutputFile = filename;
+    return this.operations;
+  }
+  async getViewExtent() {
+    console.debug("Getting view extent");
+    if (!this.olMap) {
+      throw new Error("Map not available for extent calculation");
     }
-    if (!cssOutputFile && filename.includes("app-") && filename.endsWith(".css")) {
-      cssOutputFile = filename;
+    const view = this.olMap.getView();
+    const extent2 = view.calculateExtent();
+    console.debug(`View extent: ${extent2}`);
+    return extent2;
+  }
+  async captureScreenshot() {
+    if (!this.olMap) {
+      return { success: false, error: "Map not available" };
+    }
+    const olMap = this.olMap;
+    await new Promise((resolve) => {
+      olMap.renderSync();
+      olMap.once("rendercomplete", () => resolve());
+      setTimeout(() => resolve(), 2e3);
+    });
+    const size2 = olMap.getSize();
+    const width = size2 ? size2[0] : olMap.getViewport().clientWidth;
+    const height = size2 ? size2[1] : olMap.getViewport().clientHeight;
+    try {
+      const canvas = olMap.getViewport().querySelector("canvas");
+      if (!canvas) {
+        return { success: false, error: "Map canvas not found" };
+      }
+      const dataUrl = canvas.toDataURL("image/png");
+      return { success: true, dataUrl, width, height };
+    } catch (error2) {
+      return { success: false, error: `Failed to capture canvas: ${error2.message}` };
     }
   }
-  if (!mainOutputFile) {
-    throw new Error("Could not find main output file");
+  setOnDirty(callback) {
+    this.onDirtyCallback = callback;
   }
-  const extractFilename = (filePath) => {
-    const lastSlash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
-    return lastSlash >= 0 ? filePath.substring(lastSlash + 1) : filePath;
-  };
-  return {
-    js: extractFilename(mainOutputFile),
-    css: cssOutputFile ? extractFilename(cssOutputFile) : null
-  };
-}
-function createFileSystemGsLibCopier(fs2, gsLibPackagePath) {
-  const copyFile = async (srcPath, destPath, asText, processor) => {
-    const fullSrcPath = `${gsLibPackagePath}/${srcPath}`;
-    let content = await fs2.readFile(fullSrcPath);
-    if (asText) {
-      if (content instanceof Uint8Array) {
-        content = new TextDecoder().decode(content);
-      } else {
-        content = content;
+  setOnSync(callback) {
+    this.onSyncCallback = callback;
+  }
+  triggerDirty() {
+    if (this.isDestroyed || !this.onDirtyCallback) return;
+    this.onDirtyCallback();
+  }
+  triggerSync(event) {
+    if (this.isDestroyed || !this.onSyncCallback) return;
+    this.onSyncCallback(event);
+  }
+  syncViewToModel() {
+    if (!this.olMap) return;
+    const view = this.olMap.getView();
+    const center = view.getCenter();
+    const zoom = view.getZoom();
+    const rotation = view.getRotation();
+    if (center && zoom !== void 0) {
+      this.triggerSync({
+        type: "viewChanged",
+        view: { center, zoom, rotation }
+      });
+    }
+  }
+  syncLayerFeaturesToModel(layerUuid) {
+    if (!this.olMap) return;
+    const layers = this.olMap.getLayers();
+    let olLayer;
+    for (let i5 = 0; i5 < layers.getLength(); i5++) {
+      const layer2 = layers.item(i5);
+      if (layer2.get(KEY_UUID) === layerUuid) {
+        olLayer = layer2;
+        break;
       }
-      if (processor) {
-        content = await processor(content);
+    }
+    if (!olLayer || !(olLayer instanceof VectorLayer)) return;
+    const source2 = olLayer.getSource();
+    if (!source2) return;
+    const olFeatures = source2.getFeatures();
+    const gsFeatures = olFeatures.map((olFeature) => toGsFeature(olFeature));
+    this.triggerSync({
+      type: "featuresChanged",
+      layerUuid,
+      features: gsFeatures
+    });
+  }
+  setupEventListeners() {
+    if (!this.olMap) return;
+    this.olMap.getView().on("change:center", () => {
+      this.syncViewToModel();
+      this.triggerDirty();
+    });
+    this.olMap.getView().on("change:resolution", () => {
+      this.syncViewToModel();
+      this.triggerDirty();
+    });
+    this.olMap.getView().on("change:rotation", () => {
+      this.syncViewToModel();
+      this.triggerDirty();
+    });
+    this.olMap.getLayers().on("add", () => this.triggerDirty());
+    this.olMap.getLayers().on("remove", () => this.triggerDirty());
+    this.olMap.getControls().on("add", () => this.triggerDirty());
+    this.olMap.getControls().on("remove", () => this.triggerDirty());
+    this.olMap.getOverlays().on("add", () => this.triggerDirty());
+    this.olMap.getOverlays().on("remove", () => this.triggerDirty());
+  }
+  destroy() {
+    this.isDestroyed = true;
+    this.clearStyleCache();
+    if (this.operations) {
+      const ops = this.operations;
+      if (ops.cleanup) {
+        ops.cleanup();
       }
     }
-    await fs2.writeFile(destPath, content);
-  };
-  return {
-    async copyTextFile(srcPath, destPath, processor) {
-      await copyFile(srcPath, destPath, true, processor);
-    },
-    async copyBinaryFile(srcPath, destPath) {
-      await copyFile(srcPath, destPath, false);
+    if (this.olMap) {
+      cleanupEventSubscriptions(this.olMap);
     }
-  };
+    this.olMap?.dispose();
+    this.olMap = void 0;
+  }
 }
-async function buildMap(options, fs2, resolvePlugin, esbuildInstance, config = {}, progress) {
-  const {
-    outputDir = "dist",
-    buildDir = "__build",
-    gsLibPath = `${buildDir}/gs-lib/index.js`,
-    gsLibPackagePath,
-    gsLibCopier: providedGsLibCopier,
-    cleanBeforeBuild = true,
-    cleanAfterBuild = true,
-    copyAssets
-  } = config;
-  const gsLibCopier = providedGsLibCopier || (gsLibPackagePath ? createFileSystemGsLibCopier(fs2, gsLibPackagePath) : null);
-  if (!gsLibCopier) {
-    throw new Error("Either gsLibCopier or gsLibPackagePath must be provided");
+class OpenLayersMapOperations {
+  constructor(olMap, renderer) {
+    this.olMap = olMap;
+    this.renderer = renderer;
+    if (!olMap) {
+      throw new Error("OpenLayers map is required for operations");
+    }
+    this.keyDownListener = (event) => {
+      if (event.key === "Escape") {
+        if (this.drawInteraction) {
+          this.disableDrawing();
+          this.renderer?.triggerSync({ type: "drawingDisabled" });
+        }
+        if (this.selectInteraction) {
+          this.disableSelection();
+        }
+      }
+    };
+    const target = this.olMap.getTargetElement();
+    if (target && target instanceof HTMLElement) {
+      target.setAttribute("tabindex", "-1");
+      target.addEventListener("keydown", this.keyDownListener);
+    }
   }
-  const buildGsLibPath = gsLibPath;
-  let step = config.startingStep ?? 0;
-  const totalSteps = config.totalSteps;
-  const updateProgress = (message) => {
-    if (progress) progress(++step, message, totalSteps);
-  };
-  if (cleanBeforeBuild) {
-    updateProgress("Cleaning build directories...");
-    const cleanupPromises = [];
-    if (fs2.deleteDir) {
-      cleanupPromises.push(
-        fs2.deleteDir(buildDir).catch(() => {
-        }),
-        // Ignore errors if directory doesn't exist
-        fs2.deleteDir(outputDir).catch(() => {
-        })
-      );
+  async setZoom(zoom) {
+    this.olMap.getView().setZoom(zoom);
+  }
+  async setCenter(center) {
+    this.olMap.getView().setCenter(center);
+  }
+  async switchColorMode(mode) {
+    const olMap = this.olMap;
+    let darkMode = olMap.get("darkmode") ?? false;
+    if (mode === "dark") {
+      darkMode = true;
+    } else if (mode === "light") {
+      darkMode = false;
     } else {
-      try {
-        const nodeFs = await Promise.resolve().then(() => __viteBrowserExternal);
-        const path = await Promise.resolve().then(() => __viteBrowserExternal);
-        const projectRoot = process.cwd();
-        cleanupPromises.push(
-          nodeFs.rm(path.resolve(projectRoot, buildDir), { recursive: true, force: true }).catch(() => {
-          }),
-          nodeFs.rm(path.resolve(projectRoot, outputDir), { recursive: true, force: true }).catch(() => {
-          })
-        );
-      } catch {
+      darkMode = !darkMode;
+    }
+    olMap.set("darkmode", darkMode);
+    const canvasElements = document.querySelectorAll("canvas");
+    canvasElements.forEach((canvas) => {
+      canvas.style.filter = darkMode ? "invert(100%)" : "";
+    });
+    olMap.render();
+  }
+  async addLayer(layer2, isBasemap) {
+    const olLayer = toOlLayer(layer2);
+    if (isBasemap) {
+      this.olMap.getLayers().insertAt(0, olLayer);
+    } else {
+      this.olMap.getLayers().push(olLayer);
+    }
+  }
+  async deleteLayer(uuid) {
+    const layers = this.olMap.getLayers();
+    for (let i5 = 0; i5 < layers.getLength(); i5++) {
+      const layer2 = layers.item(i5);
+      if (layer2.get(KEY_UUID) === uuid) {
+        layers.removeAt(i5);
+        return;
       }
     }
-    await Promise.all(cleanupPromises);
   }
-  updateProgress("Preparing build directories...");
-  await Promise.all([
-    fs2.ensureDir(`${outputDir}/assets/icons/`),
-    fs2.ensureDir(`${buildDir}/gs-lib/`)
-  ]);
-  updateProgress("Copying gs-lib package...");
-  await Promise.all([
-    gsLibCopier.copyTextFile("dist/index.js", `${buildDir}/gs-lib/index.js`),
-    gsLibCopier.copyTextFile("dist/gs-lib.css", `${buildDir}/gs-lib/gs-lib.css`)
-  ]);
-  updateProgress("Copying PWA core files...");
-  await gsLibCopier.copyTextFile("public/pwa/staticwebapp.config.json", `${outputDir}/staticwebapp.config.json`);
-  updateProgress("Creating manifest file...");
-  await gsLibCopier.copyTextFile("public/pwa/manifest.json", `${outputDir}/manifest.json`, (content) => processManifest(content, options.title, options.version));
-  updateProgress("Copying PWA icons...");
-  const iconFiles = [
-    "24x24.png",
-    "48x48.png",
-    "192x192.png",
-    "512x512.png",
-    "icon_24.png",
-    "icon_48.png",
-    "icon_192.png",
-    "icon_512.png"
-  ];
-  await Promise.all(iconFiles.map(
-    (icon) => gsLibCopier.copyBinaryFile(`public/pwa/assets/icons/${icon}`, `${outputDir}/assets/icons/${icon}`)
-  ));
-  if (copyAssets) {
-    updateProgress("Copying workspace assets...");
-    await copyAssets(fs2, outputDir, progress);
+  async renameLayer(uuid, newName) {
+    const layers = this.olMap.getLayers();
+    for (let i5 = 0; i5 < layers.getLength(); i5++) {
+      const layer2 = layers.item(i5);
+      if (layer2.get(KEY_UUID) === uuid) {
+        layer2.set(KEY_NAME, newName);
+        return;
+      }
+    }
   }
-  updateProgress("Generating application code...");
-  const entryPointContent = generateAppJs({
-    gsMap: options.gsMap,
-    gsLibPath: buildGsLibPath,
-    env: { ...options.env, BUILD_TIME: /* @__PURE__ */ new Date() }
-  });
-  await fs2.writeFile(`${buildDir}/app.js`, entryPointContent);
-  const stepRef = { value: step };
-  const bundleResult = await bundleApp(`${buildDir}/app.js`, outputDir, buildGsLibPath, fs2, resolvePlugin, esbuildInstance, progress, stepRef, totalSteps);
-  step = stepRef.value;
-  const appJsFilename = bundleResult.js;
-  const appCssFilename = bundleResult.css;
-  updateProgress("Generating HTML file...");
-  await gsLibCopier.copyTextFile("public/index.html", `${outputDir}/index.html`, (content) => processHtml(content, options.title, appJsFilename, appCssFilename || void 0));
-  const precacheManifest = [
-    { url: `/${appJsFilename}`, revision: null },
-    // Hashed filename handles versioning
-    ...appCssFilename ? [{ url: `/${appCssFilename}`, revision: null }] : [],
-    // Hashed CSS filename handles versioning
-    ...iconFiles.map((icon) => ({ url: `/assets/icons/${icon}`, revision: null }))
-    // Workbox will check file content
-  ];
-  updateProgress("Processing service worker...");
-  await gsLibCopier.copyTextFile(
-    "public/pwa/sw.js",
-    `${outputDir}/sw.js`,
-    (content) => processServiceWorker(content, precacheManifest)
-  );
-  if (cleanAfterBuild) {
-    updateProgress("Cleaning up temporary files...");
-    if (fs2.deleteDir) {
-      await fs2.deleteDir(buildDir);
+  async moveLayer(uuid, targetUuid) {
+    const layers = this.olMap.getLayers();
+    let fromIndex = -1;
+    let toIndex = -1;
+    for (let i5 = 0; i5 < layers.getLength(); i5++) {
+      const layer2 = layers.item(i5);
+      if (layer2.get(KEY_UUID) === uuid) {
+        fromIndex = i5;
+      }
+      if (targetUuid && layer2.get(KEY_UUID) === targetUuid) {
+        toIndex = i5;
+      }
+    }
+    if (fromIndex < 0) return;
+    if (targetUuid) {
+      if (toIndex < 0 || fromIndex === toIndex) return;
     } else {
-      try {
-        const nodeFs = await Promise.resolve().then(() => __viteBrowserExternal);
-        const path = await Promise.resolve().then(() => __viteBrowserExternal);
-        const fullPath = path.resolve(process.cwd(), buildDir);
-        await nodeFs.rm(fullPath, { recursive: true, force: true });
-      } catch (error2) {
+      toIndex = fromIndex > 0 ? fromIndex - 1 : fromIndex + 1;
+    }
+    if (toIndex >= 0 && toIndex < layers.getLength() && fromIndex !== toIndex) {
+      const layer2 = layers.item(fromIndex);
+      layers.removeAt(fromIndex);
+      layers.insertAt(toIndex, layer2);
+    }
+  }
+  async setLayerVisible(uuid, visible) {
+    const layers = this.olMap.getLayers();
+    for (let i5 = 0; i5 < layers.getLength(); i5++) {
+      const layer2 = layers.item(i5);
+      if (layer2.get(KEY_UUID) === uuid) {
+        layer2.setVisible(visible);
+        return;
       }
     }
   }
-  updateProgress("Build completed!");
+  async addControlFromModule(_src) {
+  }
+  async removeControl(_uuid) {
+  }
+  async addOverlayFromModule(_src, _position) {
+  }
+  async removeOverlay(_uuid) {
+  }
+  setCursor(cursor) {
+    const viewport = this.olMap.getViewport();
+    if (viewport) {
+      viewport.style.cursor = cursor;
+    }
+  }
+  async enableDrawing(geometryType, layerUuid) {
+    this.disableSelection();
+    if (this.drawInteraction) {
+      this.olMap.removeInteraction(this.drawInteraction);
+    }
+    this.activeDrawingLayerUuid = layerUuid;
+    this.setCursor("crosshair");
+    const layers = this.olMap.getLayers();
+    let layer$12;
+    for (let i5 = 0; i5 < layers.getLength(); i5++) {
+      const l2 = layers.item(i5);
+      if (l2.get(KEY_UUID) === layerUuid) {
+        layer$12 = l2;
+        break;
+      }
+    }
+    if (!layer$12 || !(layer$12 instanceof VectorLayer)) {
+      throw new Error("Drawing only supported on vector layers");
+    }
+    const source2 = layer$12.getSource();
+    if (!source2) {
+      throw new Error("Layer has no source");
+    }
+    const layerSourceType = layer$12.get("sourceType");
+    if (layerSourceType && layerSourceType !== GsSourceType.Features) {
+      throw new Error("Drawing only supported on layers with in-memory features");
+    }
+    this.drawInteraction = new Draw({
+      source: source2,
+      type: geometryType
+    });
+    const onFeatureAdded = (event) => {
+      const feature = event.feature;
+      if (feature && !feature.get(KEY_UUID)) {
+        const uuid = v4();
+        feature.set(KEY_UUID, uuid);
+        const state = feature.get(KEY_STATE) || {};
+        state.uuid = uuid;
+        feature.set(KEY_STATE, state);
+      }
+      if (this.renderer && this.activeDrawingLayerUuid) {
+        this.renderer.syncLayerFeaturesToModel(this.activeDrawingLayerUuid);
+      }
+      this.renderer?.triggerDirty();
+    };
+    source2.on("addfeature", onFeatureAdded);
+    this.drawInteraction._featureAddedListener = onFeatureAdded;
+    this.drawInteraction._sourceRef = source2;
+    this.olMap.addInteraction(this.drawInteraction);
+  }
+  async disableDrawing() {
+    if (this.drawInteraction) {
+      const listener = this.drawInteraction._featureAddedListener;
+      const source2 = this.drawInteraction._sourceRef;
+      if (listener && source2) {
+        source2.un("addfeature", listener);
+      }
+      this.olMap.removeInteraction(this.drawInteraction);
+      this.drawInteraction = void 0;
+      this.setCursor("");
+    }
+  }
+  cleanup() {
+    if (this.keyDownListener) {
+      const target = this.olMap.getTargetElement();
+      if (target && target instanceof HTMLElement) {
+        target.removeEventListener("keydown", this.keyDownListener);
+      }
+      this.keyDownListener = void 0;
+    }
+  }
+  async enableFeatureSelection() {
+    this.disableDrawing();
+    this.disableSelection();
+    const olLayers = this.olMap.getLayers();
+    const vectorLayers = olLayers.getArray().filter((layer$12) => layer$12 instanceof VectorLayer);
+    if (vectorLayers.length === 0) {
+      throw new Error("No vector layers available for selection");
+    }
+    const gsMap = this.renderer?.gsMap;
+    const selectionStyle = gsMap?.styles?.["selection"];
+    const selectOptions = {
+      condition: click,
+      layers: vectorLayers,
+      hitTolerance: 5,
+      style: selectionStyle ? toOlStyle(selectionStyle) : (_feature) => {
+        const stroke = new Stroke({ color: "rgba(255, 255, 0, 1)", width: 3 });
+        const fill = new Fill({ color: "rgba(255, 255, 0, 0.3)" });
+        return new Style({
+          image: new CircleStyle({ radius: 7, fill, stroke }),
+          stroke,
+          fill
+        });
+      }
+    };
+    this.selectInteraction = new Select(selectOptions);
+    this.selectInteraction.on("select", (event) => {
+      if (event.selected.length > 0) {
+        const selectedFeature = event.selected[0];
+        let featureLayerUuid;
+        olLayers.getArray().forEach((layer$12) => {
+          if (layer$12 instanceof VectorLayer) {
+            const source2 = layer$12.getSource();
+            if (source2 && source2.hasFeature(selectedFeature)) {
+              const uuid = layer$12.get(KEY_UUID);
+              if (uuid) featureLayerUuid = uuid;
+            }
+          }
+        });
+        if (featureLayerUuid && this.renderer) {
+          const gsFeature = toGsFeature(selectedFeature);
+          const geometry = selectedFeature.getGeometry();
+          const metrics = {};
+          if (geometry) {
+            const geometryType = geometry.getType();
+            try {
+              if (geometryType === "LineString" || geometryType === "MultiLineString") {
+                metrics.length = getLength(geometry, { projection: this.olMap.getView().getProjection() });
+              } else if (geometryType === "Polygon" || geometryType === "MultiPolygon") {
+                metrics.area = getArea(geometry, { projection: this.olMap.getView().getProjection() });
+                const coordinates2 = geometryType === "Polygon" ? geometry.getCoordinates()[0] : geometry.getCoordinates()[0][0];
+                if (coordinates2?.length > 0) {
+                  const perimeterLine = new LineString(coordinates2);
+                  metrics.length = getLength(perimeterLine, { projection: this.olMap.getView().getProjection() });
+                }
+              }
+            } catch (error2) {
+              console.warn("Error calculating feature metrics:", error2);
+            }
+          }
+          this.renderer.triggerSync({
+            type: "featureSelected",
+            layerUuid: featureLayerUuid,
+            feature: gsFeature,
+            metrics
+          });
+        }
+      } else if (event.deselected.length > 0) {
+        this.renderer?.triggerSync({ type: "featureDeselected" });
+      }
+    });
+    this.olMap.addInteraction(this.selectInteraction);
+    this.setCursor("pointer");
+  }
+  async deleteSelectedFeatures() {
+    if (!this.selectInteraction) {
+      throw new Error("No selection interaction active");
+    }
+    const selectedFeatures = this.selectInteraction.getFeatures();
+    if (selectedFeatures.getLength() === 0) {
+      throw new Error("No features selected");
+    }
+    const layersToSync = /* @__PURE__ */ new Set();
+    const olLayers = this.olMap.getLayers();
+    selectedFeatures.forEach((feature) => {
+      for (let i5 = 0; i5 < olLayers.getLength(); i5++) {
+        const layer$12 = olLayers.item(i5);
+        if (layer$12 instanceof VectorLayer) {
+          const source2 = layer$12.getSource();
+          if (source2 && source2.hasFeature(feature)) {
+            source2.removeFeature(feature);
+            const layerUuid = layer$12.get(KEY_UUID);
+            if (layerUuid) layersToSync.add(layerUuid);
+            break;
+          }
+        }
+      }
+    });
+    selectedFeatures.clear();
+    if (this.renderer && layersToSync.size > 0) {
+      layersToSync.forEach((layerUuid) => {
+        this.renderer.syncLayerFeaturesToModel(layerUuid);
+      });
+    }
+    this.renderer?.triggerDirty();
+  }
+  async disableSelection() {
+    if (this.selectInteraction) {
+      this.olMap.removeInteraction(this.selectInteraction);
+      this.selectInteraction = void 0;
+      this.setCursor("");
+      this.renderer?.triggerSync({ type: "featureDeselected" });
+    }
+  }
 }
 const rtUtils = {
   async resolveUrl(url) {
@@ -105600,6 +106193,7 @@ export {
   OL_SOURCES,
   BaseObject as Object,
   Observable,
+  OpenLayersMapRenderer,
   Overlay,
   Tile,
   TileQueue,
@@ -105612,6 +106206,7 @@ export {
   buildMap,
   bundleApp,
   cleanupEventSubscriptions,
+  createProxy,
   defaults$1 as defaultControls,
   defaults as defaultInteractions,
   ensureUuid,
@@ -105620,16 +106215,23 @@ export {
   events,
   condition as eventsCondition,
   extent,
+  findControlByUuid,
+  findControlIndexByUuid,
+  findLayerByUuid,
+  findLayerIndexByUuid,
+  findOverlayByUuid,
+  findOverlayIndexByUuid,
   format,
   generateAppJs,
   olGeom as geom,
   getStyleForFeature,
   getUid,
-  gsLib,
+  olLib as gsLib,
   importControlSource,
   importOverlaySource,
   interaction,
   layer,
+  olLib,
   processHtml,
   processManifest,
   processServiceWorker,