@chrtco/sdk 0.7.0 → 0.7.1

package/dist/atlas/browser.cjs

@@ -20,10 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/atlas/browser.ts
 var browser_exports = {};
 __export(browser_exports, {
+  clearS52SymbolImageCache: () => clearS52SymbolImageCache,
+  getS52AtlasVersion: () => getS52AtlasVersion,
   loadS52SymbolImages: () => loadS52SymbolImages,
+  loadS52SymbolImagesCached: () => loadS52SymbolImagesCached,
   loadSymbolImages: () => loadSymbolImages,
   loadThemedBridgeImages: () => loadThemedBridgeImages,
-  reloadS52SymbolImages: () => reloadS52SymbolImages
+  reloadS52SymbolImages: () => reloadS52SymbolImages,
+  reloadS52SymbolImagesCached: () => reloadS52SymbolImagesCached
 });
 module.exports = __toCommonJS(browser_exports);
 
@@ -807,6 +811,192 @@ async function reloadS52SymbolImages(map, colorTable) {
   await Promise.all(promises);
 }
 
+// src/atlas/s52-image-cache.ts
+var SDF_SYMBOLS2 = /* @__PURE__ */ new Set(["LIGHTS11", "LIGHTS13"]);
+var LOGICAL_SIZE2 = 32;
+var PIXEL_RATIO2 = 2;
+var RENDER_SIZE2 = LOGICAL_SIZE2 * PIXEL_RATIO2;
+var DB_NAME = "chrt-s52-atlas";
+var DB_VERSION = 1;
+var STORE_NAME = "bitmaps";
+var PARAM_VERSION = "v2";
+function computeAtlasVersion() {
+  const names = Object.keys(ALL_S52_SVGS).sort().join("|");
+  let h = 2166136261;
+  for (let i = 0; i < names.length; i++) {
+    h ^= names.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `${PARAM_VERSION}-${(h >>> 0).toString(16)}-${Object.keys(ALL_S52_SVGS).length}`;
+}
+var ATLAS_VERSION = /* @__PURE__ */ computeAtlasVersion();
+function makeKey(colorTable, name) {
+  return `${ATLAS_VERSION}:${colorTable}:${name}`;
+}
+function upsampleSvg2(svg2) {
+  return svg2.replace(
+    /width="(\d+)"\s+height="(\d+)"/,
+    `width="${RENDER_SIZE2}" height="${RENDER_SIZE2}"`
+  );
+}
+function prepareSvg2(rawSvg, colorTable) {
+  return upsampleSvg2(applyStrokeBoost(applyColorTheme(rawSvg, colorTable), S52_STROKE_BOOST));
+}
+function hasIndexedDB() {
+  return typeof indexedDB !== "undefined";
+}
+function hasCanvasToBitmap() {
+  return typeof createImageBitmap === "function" && typeof document !== "undefined" && typeof document.createElement === "function";
+}
+var dbPromise = null;
+function openDb() {
+  if (!hasIndexedDB()) return Promise.reject(new Error("IndexedDB not available"));
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME);
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error ?? new Error("indexedDB.open failed"));
+    req.onblocked = () => reject(new Error("indexedDB.open blocked"));
+  });
+  dbPromise.catch(() => {
+    dbPromise = null;
+  });
+  return dbPromise;
+}
+async function idbPut(key, value) {
+  const db = await openDb();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const req = store.put(value, key);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbGetAllForTheme(colorTable) {
+  const out = /* @__PURE__ */ new Map();
+  const db = await openDb();
+  const names = Object.keys(ALL_S52_SVGS);
+  await new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error ?? new Error("idb txn aborted"));
+    for (const name of names) {
+      const req = store.get(makeKey(colorTable, name));
+      req.onsuccess = () => {
+        const bm = req.result;
+        if (bm) out.set(name, bm);
+      };
+    }
+  });
+  return out;
+}
+function decodeSvgToImage(themedSvg) {
+  return new Promise((resolve) => {
+    const img = new Image(RENDER_SIZE2, RENDER_SIZE2);
+    img.onload = () => resolve(img);
+    img.onerror = () => resolve(null);
+    img.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(themedSvg)}`;
+  });
+}
+async function imageToBitmap(img) {
+  try {
+    const canvas = document.createElement("canvas");
+    canvas.width = RENDER_SIZE2;
+    canvas.height = RENDER_SIZE2;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    ctx.drawImage(img, 0, 0, RENDER_SIZE2, RENDER_SIZE2);
+    return await createImageBitmap(canvas);
+  } catch {
+    return null;
+  }
+}
+function addImageToMap(map, name, image) {
+  if (map.hasImage(name)) return;
+  try {
+    map.addImage(name, image, {
+      sdf: SDF_SYMBOLS2.has(name),
+      pixelRatio: PIXEL_RATIO2
+    });
+  } catch {
+  }
+}
+function getS52AtlasVersion() {
+  return ATLAS_VERSION;
+}
+async function loadS52SymbolImagesCached(map, colorTable = "DAY", opts = {}) {
+  if (!hasIndexedDB() || !hasCanvasToBitmap()) {
+    return loadS52SymbolImages(map, colorTable);
+  }
+  const names = Object.keys(ALL_S52_SVGS);
+  let cached;
+  if (opts.forceRefresh) {
+    cached = /* @__PURE__ */ new Map();
+  } else {
+    try {
+      cached = await idbGetAllForTheme(colorTable);
+    } catch {
+      cached = /* @__PURE__ */ new Map();
+    }
+  }
+  for (const [name, bitmap] of cached) {
+    addImageToMap(map, name, bitmap);
+  }
+  const missing = names.filter((n) => !cached.has(n) && !map.hasImage(n));
+  if (missing.length === 0) return;
+  await Promise.all(
+    missing.map(async (name) => {
+      const rawSvg = ALL_S52_SVGS[name];
+      if (!rawSvg) return;
+      const themed = prepareSvg2(rawSvg, colorTable);
+      const img = await decodeSvgToImage(themed);
+      if (!img) return;
+      addImageToMap(map, name, img);
+      try {
+        const bitmap = await imageToBitmap(img);
+        if (!bitmap) return;
+        await idbPut(makeKey(colorTable, name), bitmap);
+      } catch {
+      }
+    })
+  );
+}
+async function reloadS52SymbolImagesCached(map, colorTable) {
+  if (!hasIndexedDB() || !hasCanvasToBitmap()) {
+    return reloadS52SymbolImages(map, colorTable);
+  }
+  for (const name of Object.keys(ALL_S52_SVGS)) {
+    try {
+      if (map.hasImage(name)) map.removeImage(name);
+    } catch {
+    }
+  }
+  return loadS52SymbolImagesCached(map, colorTable);
+}
+async function clearS52SymbolImageCache() {
+  if (!hasIndexedDB()) return;
+  try {
+    const db = await openDb();
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      const req = store.clear();
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  } catch {
+  }
+}
+
 // src/atlas/symbols.ts
 var SIZE = 32;
 function svg(inner) {
@@ -3237,9 +3427,13 @@ async function loadThemedBridgeImages(map, colorTable) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  clearS52SymbolImageCache,
+  getS52AtlasVersion,
   loadS52SymbolImages,
+  loadS52SymbolImagesCached,
   loadSymbolImages,
   loadThemedBridgeImages,
-  reloadS52SymbolImages
+  reloadS52SymbolImages,
+  reloadS52SymbolImagesCached
 });
 //# sourceMappingURL=browser.cjs.map