@gisfun/maplibre-gl-components 0.15.0-alpha.0

package/dist/DuckDBConverter-B98M0DFs.cjs

@@ -0,0 +1,23 @@
+"use strict";var G=Object.create;var C=Object.defineProperty;var J=Object.getOwnPropertyDescriptor;var W=Object.getOwnPropertyNames;var I=Object.getPrototypeOf,M=Object.prototype.hasOwnProperty;var K=(p,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of W(e))!M.call(p,i)&&i!==t&&C(p,i,{get:()=>e[i],enumerable:!(r=J(e,i))||r.enumerable});return p};var H=(p,e,t)=>(t=p!=null?G(I(p)):{},K(e||!p||!p.__esModule?C(t,"default",{value:p,enumerable:!0}):t,p));Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});let B=null;function Y(){return B||(B=new F),B}class F{_duckdb=null;_db=null;_worker=null;_initialized=!1;_initializing=!1;_bundleUrl;constructor(e){this._bundleUrl=e}isReady(){return this._initialized&&this._db!==null}async initialize(e){if(!this._initialized){if(this._initializing){for(;this._initializing;)await new Promise(t=>setTimeout(t,50));return}this._initializing=!0;try{e?.({stage:"initializing",percent:0,message:"Loading DuckDB WASM..."});let t;try{const o=await import("@duckdb/duckdb-wasm");t=o.default||o}catch(o){throw new Error(`DuckDB WASM is not installed or failed to load. Install it with: npm install @duckdb/duckdb-wasm. Error: ${o instanceof Error?o.message:"Unknown error"}`)}this._duckdb=t,e?.({stage:"initializing",percent:30,message:"Selecting DuckDB bundle..."});let r;if(this._duckdb.getJsDelivrBundles){const o=this._duckdb.getJsDelivrBundles();r=await this._duckdb.selectBundle(o)}else{const o=this._getJsDelivrBundles();r=await this._duckdb.selectBundle(o)}e?.({stage:"initializing",percent:50,message:"Instantiating DuckDB..."});const i=new this._duckdb.ConsoleLogger(4);let g,a=null;try{a=URL.createObjectURL(new Blob([`importScripts("${r.mainWorker}");`],{type:"text/javascript"})),g=new Worker(a)}catch(o){throw a&&URL.revokeObjectURL(a),new Error(`Failed to create DuckDB worker: ${o instanceof Error?o.message:"Unknown error"}`)}this._worker=g;const w=new this._duckdb.AsyncDuckDB(i,g);try{await w.instantiate(r.mainModule,r.pthreadWorker)}catch(o){throw new Error(`Failed to instantiate DuckDB: ${o instanceof Error?o.message:"Unknown error"}`)}a&&URL.revokeObjectURL(a),this._db=w,e?.({stage:"initializing",percent:70,message:"Loading spatial extension..."});const n=await this._db.connect();try{await n.query("INSTALL spatial"),await n.query("LOAD spatial")}catch(o){console.warn("Failed to load spatial extension, some features may not work:",o)}finally{await n.close()}this._initialized=!0,e?.({stage:"initializing",percent:100,message:"DuckDB ready"})}catch(t){throw e?.({stage:"error",message:`Failed to initialize DuckDB: ${t instanceof Error?t.message:"Unknown error"}`}),t}finally{this._initializing=!1}}}_getJsDelivrBundles(){const e=this._bundleUrl||"https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@latest/dist";return{mvp:{mainModule:`${e}/duckdb-mvp.wasm`,mainWorker:`${e}/duckdb-browser-mvp.worker.js`},eh:{mainModule:`${e}/duckdb-eh.wasm`,mainWorker:`${e}/duckdb-browser-eh.worker.js`}}}async convert(e,t,r){const i=performance.now(),g=this._detectFormat(t);if(this.isReady()||await this.initialize(r),!this._db)throw new Error("DuckDB not initialized");r?.({stage:"loading",percent:0,message:`Loading ${t}...`});const a=new Uint8Array(e);await this._db.registerFileBuffer(t,a);const w=await this._db.connect();try{r?.({stage:"converting",percent:30,message:"Reading spatial data..."});let n;g==="geoparquet"||g==="parquet"?n=`read_parquet('${t}')`:n=`ST_Read('${t}')`;const y=(await w.query(`
+        DESCRIBE SELECT * FROM ${n}
+      `)).toArray();let c=null,k="",h=null,u=null,l=null;const d=[],N=["lat","latitude","y","lat_y","point_y"],E=["lon","lng","long","longitude","x","lon_x","long_x","point_x"],D=["wkt","wkt_geom","wkt_geometry","geometry_wkt"];for(const m of y){const s=m.column_name,L=m.column_type?.toUpperCase()||"",_=s.toLowerCase(),A=L.includes("GEOMETRY"),x=_==="geom"||_==="geometry"||_==="wkb_geometry"||_==="the_geom"||_==="shape",q=L.includes("BLOB")&&x;A||x||q?c||(c=s,k=L):N.includes(_)&&!h?(h=s,d.push(s)):E.includes(_)&&!u?(u=s,d.push(s)):D.includes(_)&&!l?l=s:d.push(s)}let f=!1,b=!1;if(!c)if(l)b=!0;else if(h&&u){f=!0;const m=d.indexOf(h);m>-1&&d.splice(m,1);const s=d.indexOf(u);s>-1&&d.splice(s,1)}else throw new Error("No geometry column found in the file. For CSV/Excel files, include a geometry column, WKT column, or lat/lon columns.");r?.({stage:"converting",percent:50,message:"Converting to GeoJSON..."});const v=d.length>0?`json_object(${d.map(m=>`'${m}', "${m}"`).join(", ")})`:"'{}'::JSON";let S,$;f&&h&&u?(S=`ST_AsGeoJSON(ST_Point("${u}", "${h}"))`,$=`"${h}" IS NOT NULL AND "${u}" IS NOT NULL`):b&&l?(S=`ST_AsGeoJSON(ST_GeomFromText("${l}"))`,$=`"${l}" IS NOT NULL AND "${l}" != ''`):k.includes("BLOB")?(S=`ST_AsGeoJSON(ST_GeomFromWKB("${c}"))`,$=`"${c}" IS NOT NULL`):(S=`ST_AsGeoJSON("${c}")`,$=`"${c}" IS NOT NULL`);const R=(await w.query(`
+        SELECT json_object(
+          'type', 'Feature',
+          'geometry', ${S}::JSON,
+          'properties', ${v}
+        ) as feature
+        FROM ${n}
+        WHERE ${$}
+      `)).toArray();r?.({stage:"converting",percent:80,message:"Building feature collection..."});const T=[],O=new Set;for(const m of R)if(m.feature)try{const s=typeof m.feature=="string"?JSON.parse(m.feature):m.feature;T.push(s),s.geometry?.type&&O.add(s.geometry.type)}catch(s){console.warn("Failed to parse feature:",s)}const U={type:"FeatureCollection",features:T},z=performance.now(),j={originalFormat:g,featureCount:T.length,geometryTypes:Array.from(O),fileSize:e.byteLength,conversionTimeMs:Math.round(z-i)};return r?.({stage:"complete",percent:100,message:`Converted ${T.length} features`}),{geojson:U,warnings:[],metadata:j}}catch(n){throw r?.({stage:"error",message:`Failed to convert: ${n instanceof Error?n.message:"Unknown error"}`}),n}finally{await w.close();try{await this._db.dropFile(t)}catch{}}}_detectFormat(e){switch(e.toLowerCase().split(".").pop()){case"gpkg":return"geopackage";case"parquet":case"geoparquet":return"geoparquet";case"shp":return"shapefile";case"geojson":case"json":return"geojson";case"kml":return"kml";case"kmz":return"kmz";case"gpx":return"gpx";case"fgb":return"flatgeobuf";case"gml":return"gml";case"topojson":return"topojson";case"csv":return"csv";case"xlsx":case"xls":return"xlsx";case"dxf":return"dxf";default:return"unknown"}}async registerRemoteParquet(e,t){if(this.isReady()||await this.initialize(),!this._db||!this._duckdb)throw new Error("DuckDB not initialized");await this._db.registerFileURL(t,e,this._duckdb.DuckDBDataProtocol.HTTP,!1)}async getParquetSchema(e){if(!this._db)throw new Error("DuckDB not initialized");const t=await this._db.connect();try{const i=(await t.query(`DESCRIBE SELECT * FROM read_parquet('${e}')`)).toArray(),g=i.map(y=>({name:y.column_name,type:y.column_type}));let a=null,w=null;const n=[],o=["geom","geometry","wkb_geometry","the_geom","shape"];for(const y of i){const c=y.column_name,k=y.column_type?.toUpperCase()||"",h=c.toLowerCase(),u=k.includes("GEOMETRY"),l=o.includes(h),d=k.includes("BLOB")&&l;(u||l||d)&&!a?(a=c,w=k):n.push(c)}return{geometryColumn:a,geometryColumnType:w,propertyColumns:n,allColumns:g}}finally{await t.close()}}async queryByBounds(e,t,r,i,g){if(!this._db)throw new Error("DuckDB not initialized");const a=await this._db.connect(),[w,n,o,y]=t;try{const c=i.length>0?`json_object(${i.map(f=>`'${f}', "${f}"`).join(", ")})`:"'{}'::JSON",h=(g?.toUpperCase()||"").includes("BLOB");let u,l;h?(u=`ST_AsGeoJSON(ST_GeomFromWKB("${r}"))`,l=`ST_GeomFromWKB("${r}")`):(u=`ST_AsGeoJSON("${r}")`,l=`"${r}"`);const d=`
+        SELECT json_object(
+          'type', 'Feature',
+          'geometry', ${u}::JSON,
+          'properties', ${c}
+        ) as feature
+        FROM read_parquet('${e}')
+        WHERE "${r}" IS NOT NULL
+          AND ST_Intersects(
+            ${l},
+            ST_MakeEnvelope(${w}, ${n}, ${o}, ${y})
+          )
+      `,E=(await a.query(d)).toArray(),D=[];for(const f of E)if(f.feature)try{const b=typeof f.feature=="string"?JSON.parse(f.feature):f.feature;D.push(b)}catch(b){console.warn("Failed to parse feature:",b)}return{type:"FeatureCollection",features:D}}finally{await a.close()}}async unregisterFile(e){if(this._db)try{await this._db.dropFile(e)}catch{}}dispose(){this._db&&(this._db.terminate().catch(console.error),this._db=null),this._worker&&(this._worker.terminate(),this._worker=null),this._initialized=!1,this._duckdb=null,B===this&&(B=null)}}exports.DuckDBConverter=F;exports.getDuckDBConverter=Y;

package/dist/DuckDBConverter-RPq48-t0.js

@@ -0,0 +1,434 @@
+let S = null;
+function G() {
+  return S || (S = new j()), S;
+}
+class j {
+  _duckdb = null;
+  _db = null;
+  _worker = null;
+  _initialized = !1;
+  _initializing = !1;
+  _bundleUrl;
+  /**
+   * Creates a new DuckDBConverter instance.
+   *
+   * @param bundleUrl - Optional custom URL for DuckDB WASM bundles.
+   */
+  constructor(e) {
+    this._bundleUrl = e;
+  }
+  /**
+   * Checks if the converter is ready for use.
+   *
+   * @returns True if initialized and ready.
+   */
+  isReady() {
+    return this._initialized && this._db !== null;
+  }
+  /**
+   * Initializes DuckDB WASM with the spatial extension.
+   *
+   * @param onProgress - Optional progress callback.
+   */
+  async initialize(e) {
+    if (!this._initialized) {
+      if (this._initializing) {
+        for (; this._initializing; )
+          await new Promise((t) => setTimeout(t, 50));
+        return;
+      }
+      this._initializing = !0;
+      try {
+        e?.({
+          stage: "initializing",
+          percent: 0,
+          message: "Loading DuckDB WASM..."
+        });
+        let t;
+        try {
+          const r = await import(
+            /* @vite-ignore */
+            "@duckdb/duckdb-wasm"
+          );
+          t = r.default || r;
+        } catch (r) {
+          throw new Error(
+            `DuckDB WASM is not installed or failed to load. Install it with: npm install @duckdb/duckdb-wasm. Error: ${r instanceof Error ? r.message : "Unknown error"}`
+          );
+        }
+        this._duckdb = t, e?.({
+          stage: "initializing",
+          percent: 30,
+          message: "Selecting DuckDB bundle..."
+        });
+        let n;
+        if (this._duckdb.getJsDelivrBundles) {
+          const r = this._duckdb.getJsDelivrBundles();
+          n = await this._duckdb.selectBundle(r);
+        } else {
+          const r = this._getJsDelivrBundles();
+          n = await this._duckdb.selectBundle(r);
+        }
+        e?.({
+          stage: "initializing",
+          percent: 50,
+          message: "Instantiating DuckDB..."
+        });
+        const h = new this._duckdb.ConsoleLogger(4);
+        let m, i = null;
+        try {
+          i = URL.createObjectURL(
+            new Blob([`importScripts("${n.mainWorker}");`], {
+              type: "text/javascript"
+            })
+          ), m = new Worker(i);
+        } catch (r) {
+          throw i && URL.revokeObjectURL(i), new Error(
+            `Failed to create DuckDB worker: ${r instanceof Error ? r.message : "Unknown error"}`
+          );
+        }
+        this._worker = m;
+        const p = new this._duckdb.AsyncDuckDB(h, m);
+        try {
+          await p.instantiate(n.mainModule, n.pthreadWorker);
+        } catch (r) {
+          throw new Error(
+            `Failed to instantiate DuckDB: ${r instanceof Error ? r.message : "Unknown error"}`
+          );
+        }
+        i && URL.revokeObjectURL(i), this._db = p, e?.({
+          stage: "initializing",
+          percent: 70,
+          message: "Loading spatial extension..."
+        });
+        const o = await this._db.connect();
+        try {
+          await o.query("INSTALL spatial"), await o.query("LOAD spatial");
+        } catch (r) {
+          console.warn(
+            "Failed to load spatial extension, some features may not work:",
+            r
+          );
+        } finally {
+          await o.close();
+        }
+        this._initialized = !0, e?.({
+          stage: "initializing",
+          percent: 100,
+          message: "DuckDB ready"
+        });
+      } catch (t) {
+        throw e?.({
+          stage: "error",
+          message: `Failed to initialize DuckDB: ${t instanceof Error ? t.message : "Unknown error"}`
+        }), t;
+      } finally {
+        this._initializing = !1;
+      }
+    }
+  }
+  /**
+   * Gets the jsdelivr bundle URLs for DuckDB WASM.
+   */
+  _getJsDelivrBundles() {
+    const e = this._bundleUrl || "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@latest/dist";
+    return {
+      mvp: {
+        mainModule: `${e}/duckdb-mvp.wasm`,
+        mainWorker: `${e}/duckdb-browser-mvp.worker.js`
+      },
+      eh: {
+        mainModule: `${e}/duckdb-eh.wasm`,
+        mainWorker: `${e}/duckdb-browser-eh.worker.js`
+      }
+    };
+  }
+  /**
+   * Converts a spatial file to GeoJSON using DuckDB.
+   *
+   * @param buffer - The file contents as an ArrayBuffer.
+   * @param filename - The original filename.
+   * @param onProgress - Optional progress callback.
+   * @returns The conversion result with GeoJSON.
+   */
+  async convert(e, t, n) {
+    const h = performance.now(), m = this._detectFormat(t);
+    if (this.isReady() || await this.initialize(n), !this._db)
+      throw new Error("DuckDB not initialized");
+    n?.({
+      stage: "loading",
+      percent: 0,
+      message: `Loading ${t}...`
+    });
+    const i = new Uint8Array(e);
+    await this._db.registerFileBuffer(t, i);
+    const p = await this._db.connect();
+    try {
+      n?.({
+        stage: "converting",
+        percent: 30,
+        message: "Reading spatial data..."
+      });
+      let o;
+      m === "geoparquet" || m === "parquet" ? o = `read_parquet('${t}')` : o = `ST_Read('${t}')`;
+      const f = (await p.query(`
+        DESCRIBE SELECT * FROM ${o}
+      `)).toArray();
+      let l = null, y = "", g = null, c = null, a = null;
+      const u = [], L = ["lat", "latitude", "y", "lat_y", "point_y"], E = [
+        "lon",
+        "lng",
+        "long",
+        "longitude",
+        "x",
+        "lon_x",
+        "long_x",
+        "point_x"
+      ], B = ["wkt", "wkt_geom", "wkt_geometry", "geometry_wkt"];
+      for (const d of f) {
+        const s = d.column_name, D = d.column_type?.toUpperCase() || "", _ = s.toLowerCase(), z = D.includes("GEOMETRY"), O = _ === "geom" || _ === "geometry" || _ === "wkb_geometry" || _ === "the_geom" || _ === "shape", v = D.includes("BLOB") && O;
+        z || O || v ? l || (l = s, y = D) : L.includes(_) && !g ? (g = s, u.push(s)) : E.includes(_) && !c ? (c = s, u.push(s)) : B.includes(_) && !a ? a = s : u.push(s);
+      }
+      let w = !1, k = !1;
+      if (!l)
+        if (a)
+          k = !0;
+        else if (g && c) {
+          w = !0;
+          const d = u.indexOf(g);
+          d > -1 && u.splice(d, 1);
+          const s = u.indexOf(c);
+          s > -1 && u.splice(s, 1);
+        } else
+          throw new Error(
+            "No geometry column found in the file. For CSV/Excel files, include a geometry column, WKT column, or lat/lon columns."
+          );
+      n?.({
+        stage: "converting",
+        percent: 50,
+        message: "Converting to GeoJSON..."
+      });
+      const x = u.length > 0 ? `json_object(${u.map((d) => `'${d}', "${d}"`).join(", ")})` : "'{}'::JSON";
+      let b, $;
+      w && g && c ? (b = `ST_AsGeoJSON(ST_Point("${c}", "${g}"))`, $ = `"${g}" IS NOT NULL AND "${c}" IS NOT NULL`) : k && a ? (b = `ST_AsGeoJSON(ST_GeomFromText("${a}"))`, $ = `"${a}" IS NOT NULL AND "${a}" != ''`) : y.includes("BLOB") ? (b = `ST_AsGeoJSON(ST_GeomFromWKB("${l}"))`, $ = `"${l}" IS NOT NULL`) : (b = `ST_AsGeoJSON("${l}")`, $ = `"${l}" IS NOT NULL`);
+      const F = (await p.query(`
+        SELECT json_object(
+          'type', 'Feature',
+          'geometry', ${b}::JSON,
+          'properties', ${x}
+        ) as feature
+        FROM ${o}
+        WHERE ${$}
+      `)).toArray();
+      n?.({
+        stage: "converting",
+        percent: 80,
+        message: "Building feature collection..."
+      });
+      const T = [], N = /* @__PURE__ */ new Set();
+      for (const d of F)
+        if (d.feature)
+          try {
+            const s = typeof d.feature == "string" ? JSON.parse(d.feature) : d.feature;
+            T.push(s), s.geometry?.type && N.add(s.geometry.type);
+          } catch (s) {
+            console.warn("Failed to parse feature:", s);
+          }
+      const C = {
+        type: "FeatureCollection",
+        features: T
+      }, R = performance.now(), U = {
+        originalFormat: m,
+        featureCount: T.length,
+        geometryTypes: Array.from(N),
+        fileSize: e.byteLength,
+        conversionTimeMs: Math.round(R - h)
+      };
+      return n?.({
+        stage: "complete",
+        percent: 100,
+        message: `Converted ${T.length} features`
+      }), {
+        geojson: C,
+        warnings: [],
+        metadata: U
+      };
+    } catch (o) {
+      throw n?.({
+        stage: "error",
+        message: `Failed to convert: ${o instanceof Error ? o.message : "Unknown error"}`
+      }), o;
+    } finally {
+      await p.close();
+      try {
+        await this._db.dropFile(t);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Detects the file format from the filename.
+   *
+   * @param filename - The filename to check.
+   * @returns The detected format name.
+   */
+  _detectFormat(e) {
+    switch (e.toLowerCase().split(".").pop()) {
+      case "gpkg":
+        return "geopackage";
+      case "parquet":
+      case "geoparquet":
+        return "geoparquet";
+      case "shp":
+        return "shapefile";
+      case "geojson":
+      case "json":
+        return "geojson";
+      case "kml":
+        return "kml";
+      case "kmz":
+        return "kmz";
+      case "gpx":
+        return "gpx";
+      case "fgb":
+        return "flatgeobuf";
+      case "gml":
+        return "gml";
+      case "topojson":
+        return "topojson";
+      case "csv":
+        return "csv";
+      case "xlsx":
+      case "xls":
+        return "xlsx";
+      case "dxf":
+        return "dxf";
+      default:
+        return "unknown";
+    }
+  }
+  /**
+   * Registers a remote parquet file for HTTP range request access.
+   * This allows querying the file without downloading it entirely.
+   *
+   * @param url - The URL of the remote parquet file.
+   * @param fileName - The internal filename to use for queries.
+   */
+  async registerRemoteParquet(e, t) {
+    if (this.isReady() || await this.initialize(), !this._db || !this._duckdb)
+      throw new Error("DuckDB not initialized");
+    await this._db.registerFileURL(
+      t,
+      e,
+      this._duckdb.DuckDBDataProtocol.HTTP,
+      !1
+      // not direct IO
+    );
+  }
+  /**
+   * Gets the schema of a parquet file, identifying geometry and property columns.
+   *
+   * @param fileName - The registered filename to analyze.
+   * @returns Schema information with geometry and property columns.
+   */
+  async getParquetSchema(e) {
+    if (!this._db)
+      throw new Error("DuckDB not initialized");
+    const t = await this._db.connect();
+    try {
+      const h = (await t.query(`DESCRIBE SELECT * FROM read_parquet('${e}')`)).toArray(), m = h.map((f) => ({
+        name: f.column_name,
+        type: f.column_type
+      }));
+      let i = null, p = null;
+      const o = [], r = [
+        "geom",
+        "geometry",
+        "wkb_geometry",
+        "the_geom",
+        "shape"
+      ];
+      for (const f of h) {
+        const l = f.column_name, y = f.column_type?.toUpperCase() || "", g = l.toLowerCase(), c = y.includes("GEOMETRY"), a = r.includes(g), u = y.includes("BLOB") && a;
+        (c || a || u) && !i ? (i = l, p = y) : o.push(l);
+      }
+      return {
+        geometryColumn: i,
+        geometryColumnType: p,
+        propertyColumns: o,
+        allColumns: m
+      };
+    } finally {
+      await t.close();
+    }
+  }
+  /**
+   * Queries features from a registered parquet file within the given bounds.
+   *
+   * @param fileName - The registered filename to query.
+   * @param bounds - The bounding box [west, south, east, north].
+   * @param geometryColumn - The name of the geometry column.
+   * @param propertyColumns - The property columns to include.
+   * @param geometryColumnType - The type of the geometry column (for WKB handling).
+   * @returns A GeoJSON FeatureCollection with features in the bounds.
+   */
+  async queryByBounds(e, t, n, h, m) {
+    if (!this._db)
+      throw new Error("DuckDB not initialized");
+    const i = await this._db.connect(), [p, o, r, f] = t;
+    try {
+      const l = h.length > 0 ? `json_object(${h.map((w) => `'${w}', "${w}"`).join(", ")})` : "'{}'::JSON", g = (m?.toUpperCase() || "").includes("BLOB");
+      let c, a;
+      g ? (c = `ST_AsGeoJSON(ST_GeomFromWKB("${n}"))`, a = `ST_GeomFromWKB("${n}")`) : (c = `ST_AsGeoJSON("${n}")`, a = `"${n}"`);
+      const u = `
+        SELECT json_object(
+          'type', 'Feature',
+          'geometry', ${c}::JSON,
+          'properties', ${l}
+        ) as feature
+        FROM read_parquet('${e}')
+        WHERE "${n}" IS NOT NULL
+          AND ST_Intersects(
+            ${a},
+            ST_MakeEnvelope(${p}, ${o}, ${r}, ${f})
+          )
+      `, E = (await i.query(u)).toArray(), B = [];
+      for (const w of E)
+        if (w.feature)
+          try {
+            const k = typeof w.feature == "string" ? JSON.parse(w.feature) : w.feature;
+            B.push(k);
+          } catch (k) {
+            console.warn("Failed to parse feature:", k);
+          }
+      return {
+        type: "FeatureCollection",
+        features: B
+      };
+    } finally {
+      await i.close();
+    }
+  }
+  /**
+   * Unregisters a file from DuckDB.
+   *
+   * @param fileName - The filename to unregister.
+   */
+  async unregisterFile(e) {
+    if (this._db)
+      try {
+        await this._db.dropFile(e);
+      } catch {
+      }
+  }
+  /**
+   * Disposes of DuckDB resources.
+   */
+  dispose() {
+    this._db && (this._db.terminate().catch(console.error), this._db = null), this._worker && (this._worker.terminate(), this._worker = null), this._initialized = !1, this._duckdb = null, S === this && (S = null);
+  }
+}
+export {
+  j as DuckDBConverter,
+  G as getDuckDBConverter
+};

package/dist/ShapefileConverter-AjbEjEyq.cjs

@@ -0,0 +1 @@
+"use strict";var y=Object.create;var h=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var w=Object.getPrototypeOf,C=Object.prototype.hasOwnProperty;var j=(t,e,s,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of d(e))!C.call(t,r)&&r!==s&&h(t,r,{get:()=>e[r],enumerable:!(i=m(e,r))||i.enumerable});return t};var v=(t,e,s)=>(s=t!=null?y(w(t)):{},j(e||!t||!t.__esModule?h(s,"default",{value:t,enumerable:!0}):s,t));Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class c{_shpjs=null;_initialized=!1;isReady(){return this._initialized&&this._shpjs!==null}async initialize(e){if(!this._initialized){e?.({stage:"initializing",percent:0,message:"Loading shapefile parser..."});try{this._shpjs=await import("shpjs"),this._initialized=!0,e?.({stage:"initializing",percent:100,message:"Shapefile parser ready"})}catch{throw new Error("shpjs is not installed. Install it with: npm install shpjs")}}}async convert(e,s,i){const r=performance.now();this.isReady()||await this.initialize(i),i?.({stage:"loading",percent:10,message:`Loading ${s}...`});try{i?.({stage:"converting",percent:30,message:"Parsing shapefile..."});const n=await(this._shpjs.default||this._shpjs)(e);i?.({stage:"converting",percent:80,message:"Building feature collection..."});let a;Array.isArray(n)?a={type:"FeatureCollection",features:n.flatMap(o=>o.features||[])}:n.type==="FeatureCollection"?a=n:n.type==="Feature"?a={type:"FeatureCollection",features:[n]}:a={type:"FeatureCollection",features:[{type:"Feature",properties:{},geometry:n}]};const f=new Set;for(const o of a.features)o.geometry&&f.add(o.geometry.type);const g=performance.now(),u={originalFormat:"shapefile",featureCount:a.features.length,geometryTypes:Array.from(f),fileSize:e.byteLength,conversionTimeMs:Math.round(g-r)};return i?.({stage:"complete",percent:100,message:`Converted ${a.features.length} features`}),{geojson:a,warnings:[],metadata:u}}catch(l){throw i?.({stage:"error",message:`Failed to parse shapefile: ${l instanceof Error?l.message:"Unknown error"}`}),l}}dispose(){this._shpjs=null,this._initialized=!1}}let p=null;function _(){return p||(p=new c),p}exports.ShapefileConverter=c;exports.getShapefileConverter=_;

package/dist/ShapefileConverter-trvt8J3z.js

@@ -0,0 +1,125 @@
+class f {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _shpjs = null;
+  _initialized = !1;
+  /**
+   * Checks if the converter is ready for use.
+   *
+   * @returns True if initialized and ready.
+   */
+  isReady() {
+    return this._initialized && this._shpjs !== null;
+  }
+  /**
+   * Initializes the shpjs library.
+   *
+   * @param onProgress - Optional progress callback.
+   */
+  async initialize(a) {
+    if (!this._initialized) {
+      a?.({
+        stage: "initializing",
+        percent: 0,
+        message: "Loading shapefile parser..."
+      });
+      try {
+        this._shpjs = await import(
+          /* @vite-ignore */
+          "shpjs"
+        ), this._initialized = !0, a?.({
+          stage: "initializing",
+          percent: 100,
+          message: "Shapefile parser ready"
+        });
+      } catch {
+        throw new Error(
+          "shpjs is not installed. Install it with: npm install shpjs"
+        );
+      }
+    }
+  }
+  /**
+   * Converts a Shapefile (ZIP) to GeoJSON.
+   *
+   * @param buffer - The ZIP file contents as an ArrayBuffer.
+   * @param filename - The original filename.
+   * @param onProgress - Optional progress callback.
+   * @returns The conversion result with GeoJSON.
+   */
+  async convert(a, o, i) {
+    const p = performance.now();
+    this.isReady() || await this.initialize(i), i?.({
+      stage: "loading",
+      percent: 10,
+      message: `Loading ${o}...`
+    });
+    try {
+      i?.({
+        stage: "converting",
+        percent: 30,
+        message: "Parsing shapefile..."
+      });
+      const t = await (this._shpjs.default || this._shpjs)(a);
+      i?.({
+        stage: "converting",
+        percent: 80,
+        message: "Building feature collection..."
+      });
+      let e;
+      Array.isArray(t) ? e = {
+        type: "FeatureCollection",
+        features: t.flatMap((r) => r.features || [])
+      } : t.type === "FeatureCollection" ? e = t : t.type === "Feature" ? e = {
+        type: "FeatureCollection",
+        features: [t]
+      } : e = {
+        type: "FeatureCollection",
+        features: [
+          {
+            type: "Feature",
+            properties: {},
+            geometry: t
+          }
+        ]
+      };
+      const l = /* @__PURE__ */ new Set();
+      for (const r of e.features)
+        r.geometry && l.add(r.geometry.type);
+      const h = performance.now(), c = {
+        originalFormat: "shapefile",
+        featureCount: e.features.length,
+        geometryTypes: Array.from(l),
+        fileSize: a.byteLength,
+        conversionTimeMs: Math.round(h - p)
+      };
+      return i?.({
+        stage: "complete",
+        percent: 100,
+        message: `Converted ${e.features.length} features`
+      }), {
+        geojson: e,
+        warnings: [],
+        metadata: c
+      };
+    } catch (s) {
+      throw i?.({
+        stage: "error",
+        message: `Failed to parse shapefile: ${s instanceof Error ? s.message : "Unknown error"}`
+      }), s;
+    }
+  }
+  /**
+   * Disposes of resources (no-op for shpjs).
+   */
+  dispose() {
+    this._shpjs = null, this._initialized = !1;
+  }
+}
+let n = null;
+function u() {
+  return n || (n = new f()), n;
+}
+export {
+  f as ShapefileConverter,
+  u as getShapefileConverter
+};