@summeruse/ol 0.0.1-beta.5 → 0.1.0

package/es/composables/useGraticule/index.mjs

@@ -1,7 +1,7 @@
 import { Graticule as a } from "ol/layer";
 import { Stroke as o } from "ol/style";
 import { ref as i, watch as u, toValue as w } from "vue";
-const h = (e) => {
+function h(e) {
   const r = i(e.defaultShow || !1);
   let t = new a({
     strokeStyle: e.strokeStyle || new o({
@@ -38,7 +38,7 @@ const h = (e) => {
   ), {
     showGraticule: r
   };
-};
+}
 export {
   h as useGraticule
 };

package/es/composables/useSwitchBaseLayer/index.d.ts

@@ -1,11 +1,11 @@
 import { Map as OLMap } from 'ol';
 import { default as TileLayer } from 'ol/layer/Tile';
-export declare const useSwitchBaseLayer: (data: {
+export declare function useSwitchBaseLayer(data: {
     olMap: OLMap;
     defaultLayerName?: string;
     layers: {
         [key: string]: TileLayer[];
     };
-}) => {
+}): {
     visibleLayerName: import('vue').Ref<string, string>;
 };

package/es/composables/useSwitchBaseLayer/index.mjs

@@ -1,17 +1,17 @@
-import { ref as l, watch as m } from "vue";
-const y = (e) => {
-  const r = l(e.defaultLayerName || Object.keys(e.layers)[0]);
-  return Object.values(e.layers).map((s) => {
-    s.map((a) => {
+import { ref as t, watch as o } from "vue";
+function f(e) {
+  const r = t(e.defaultLayerName || Object.keys(e.layers)[0]);
+  return Object.values(e.layers).forEach((s) => {
+    s.forEach((a) => {
       e.olMap.addLayer(a);
     });
-  }), m(
+  }), o(
     r,
     () => {
-      Object.entries(e.layers).map(([s, a]) => {
-        const t = s === r.value;
-        a.map((i) => {
-          i.setVisible(t);
+      Object.entries(e.layers).forEach(([s, a]) => {
+        const c = s === r.value;
+        a.forEach((i) => {
+          i.setVisible(c);
         });
       });
     },
@@ -19,7 +19,7 @@ const y = (e) => {
       immediate: !0
     }
   ), { visibleLayerName: r };
-};
+}
 export {
-  y as useSwitchBaseLayer
+  f as useSwitchBaseLayer
 };

package/es/index.mjs

@@ -1,75 +1,75 @@
 import { default as r } from "./components/n-ol-contextmenu/index.vue.mjs";
-import { default as a } from "./components/ol-map/index.vue.mjs";
-import { olMapInjectionKey as i } from "./components/ol-map/props.mjs";
-import { default as l } from "./components/n-ol-pointermove/index.vue.mjs";
-import { useGraticule as u } from "./composables/useGraticule/index.mjs";
-import { useSwitchBaseLayer as m } from "./composables/useSwitchBaseLayer/index.mjs";
-import { useDrawLineString as f } from "./composables/useDrawLineString/index.mjs";
-import { useDrawPolygon as p } from "./composables/useDrawPolygon/index.mjs";
+import { default as a } from "./components/n-ol-pointermove/index.vue.mjs";
+import { default as i } from "./components/ol-map/index.vue.mjs";
+import { olMapInjectionKey as l } from "./components/ol-map/props.mjs";
+import { useDrawLineString as u } from "./composables/useDrawLineString/index.mjs";
+import { useDrawPolygon as m } from "./composables/useDrawPolygon/index.mjs";
+import { useGraticule as f } from "./composables/useGraticule/index.mjs";
+import { useSwitchBaseLayer as p } from "./composables/useSwitchBaseLayer/index.mjs";
 import { ONE_NM as E } from "./constants/distance.mjs";
 import { EPSG_3857 as M, EPSG_4326 as y, WGS84Projection as G, WebMercatorProjection as L } from "./constants/projection.mjs";
-import { createVectorLayer as C, getBingLayer as F, getOSMLayer as O, getTianDiTuLayer as w, getTianDiTuUrl as D } from "./utils/layer/index.mjs";
-import { getAngle as d, getArea as A, getCenter as W, getDestinationPoint as j, getExtentCenter as h, getLineLength as B } from "./utils/calculate/index.mjs";
-import { kmToNauticalMiles as b, nauticalMilesToKm as k } from "./utils/distance/index.mjs";
-import { toOlAngle as I, toTurfAngle as R } from "./utils/format/index.mjs";
-import { EPSG_3857ExtentToEPSG_4326 as V, EPSG_3857ToEPSG_4326 as q, EPSG_4326ExtentToEPSG_3857 as z, EPSG_4326ToEPSG_3857 as H, mercatorExtentToWgs84 as J, mercatorToWgs84 as Q, wgs84ExtentToMercator as X, wgs84ToMercator as Y } from "./utils/projection/index.mjs";
-import { getRealCircleCoordinates as $ } from "./utils/realCircle/index.mjs";
-import { createCircleStyle as te, createStyle as re, createTextStyle as oe } from "./utils/style/index.mjs";
-import { createCircle as ne, createCircleFeature as ie, createFeature as ce, createLineString as le, createLineStringFeature as ge, createMultiLineString as ue, createMultiLineStringFeature as xe, createMultiPoint as me, createMultiPointFeature as Pe, createMultiPolygon as fe, createMultiPolygonFeature as Se, createPoint as pe, createPointFeature as se, createPolygon as Ee, createPolygonFeature as Te } from "./utils/feature/index.mjs";
+import { getAngle as C, getArea as F, getCenter as O, getDestinationPoint as w, getExtentCenter as D, getLineLength as N } from "./utils/calculate/index.mjs";
+import { kmToNauticalMiles as A, nauticalMilesToKm as W } from "./utils/distance/index.mjs";
+import { createCircle as h, createCircleFeature as B, createFeature as K, createLineString as b, createLineStringFeature as k, createMultiLineString as v, createMultiLineStringFeature as I, createMultiPoint as R, createMultiPointFeature as U, createMultiPolygon as V, createMultiPolygonFeature as q, createPoint as z, createPointFeature as H, createPolygon as J, createPolygonFeature as Q } from "./utils/feature/index.mjs";
+import { toOlAngle as Y, toTurfAngle as Z } from "./utils/format/index.mjs";
+import { createVectorLayer as ee, getBingLayer as te, getOSMLayer as re, getTianDiTuLayer as oe, getTianDiTuUrl as ae } from "./utils/layer/index.mjs";
+import { EPSG_3857ExtentToEPSG_4326 as ie, EPSG_3857ToEPSG_4326 as ce, EPSG_4326ExtentToEPSG_3857 as le, EPSG_4326ToEPSG_3857 as ge, mercatorExtentToWgs84 as ue, mercatorToWgs84 as xe, wgs84ExtentToMercator as me, wgs84ToMercator as Pe } from "./utils/projection/index.mjs";
+import { getRealCircleCoordinates as Se } from "./utils/realCircle/index.mjs";
+import { createCircleStyle as se, createStyle as Ee, createTextStyle as Te } from "./utils/style/index.mjs";
 export {
   M as EPSG_3857,
-  V as EPSG_3857ExtentToEPSG_4326,
-  q as EPSG_3857ToEPSG_4326,
+  ie as EPSG_3857ExtentToEPSG_4326,
+  ce as EPSG_3857ToEPSG_4326,
   y as EPSG_4326,
-  z as EPSG_4326ExtentToEPSG_3857,
-  H as EPSG_4326ToEPSG_3857,
+  le as EPSG_4326ExtentToEPSG_3857,
+  ge as EPSG_4326ToEPSG_3857,
   r as NOlContextmenu,
-  l as NOlPointermove,
+  a as NOlPointermove,
   E as ONE_NM,
-  a as OlMap,
+  i as OlMap,
   G as WGS84Projection,
   L as WebMercatorProjection,
-  ne as createCircle,
-  ie as createCircleFeature,
-  te as createCircleStyle,
-  ce as createFeature,
-  le as createLineString,
-  ge as createLineStringFeature,
-  ue as createMultiLineString,
-  xe as createMultiLineStringFeature,
-  me as createMultiPoint,
-  Pe as createMultiPointFeature,
-  fe as createMultiPolygon,
-  Se as createMultiPolygonFeature,
-  pe as createPoint,
-  se as createPointFeature,
-  Ee as createPolygon,
-  Te as createPolygonFeature,
-  re as createStyle,
-  oe as createTextStyle,
-  C as createVectorLayer,
-  d as getAngle,
-  A as getArea,
-  F as getBingLayer,
-  W as getCenter,
-  j as getDestinationPoint,
-  h as getExtentCenter,
-  B as getLineLength,
-  O as getOSMLayer,
-  $ as getRealCircleCoordinates,
-  w as getTianDiTuLayer,
-  D as getTianDiTuUrl,
-  b as kmToNauticalMiles,
-  J as mercatorExtentToWgs84,
-  Q as mercatorToWgs84,
-  k as nauticalMilesToKm,
-  i as olMapInjectionKey,
-  I as toOlAngle,
-  R as toTurfAngle,
-  f as useDrawLineString,
-  p as useDrawPolygon,
-  u as useGraticule,
-  m as useSwitchBaseLayer,
-  X as wgs84ExtentToMercator,
-  Y as wgs84ToMercator
+  h as createCircle,
+  B as createCircleFeature,
+  se as createCircleStyle,
+  K as createFeature,
+  b as createLineString,
+  k as createLineStringFeature,
+  v as createMultiLineString,
+  I as createMultiLineStringFeature,
+  R as createMultiPoint,
+  U as createMultiPointFeature,
+  V as createMultiPolygon,
+  q as createMultiPolygonFeature,
+  z as createPoint,
+  H as createPointFeature,
+  J as createPolygon,
+  Q as createPolygonFeature,
+  Ee as createStyle,
+  Te as createTextStyle,
+  ee as createVectorLayer,
+  C as getAngle,
+  F as getArea,
+  te as getBingLayer,
+  O as getCenter,
+  w as getDestinationPoint,
+  D as getExtentCenter,
+  N as getLineLength,
+  re as getOSMLayer,
+  Se as getRealCircleCoordinates,
+  oe as getTianDiTuLayer,
+  ae as getTianDiTuUrl,
+  A as kmToNauticalMiles,
+  ue as mercatorExtentToWgs84,
+  xe as mercatorToWgs84,
+  W as nauticalMilesToKm,
+  l as olMapInjectionKey,
+  Y as toOlAngle,
+  Z as toTurfAngle,
+  u as useDrawLineString,
+  m as useDrawPolygon,
+  f as useGraticule,
+  p as useSwitchBaseLayer,
+  me as wgs84ExtentToMercator,
+  Pe as wgs84ToMercator
 };

package/es/utils/calculate/index.d.ts

@@ -1,22 +1,24 @@
 import { Coordinate } from 'ol/coordinate';
 import { Extent } from 'ol/extent';
-/** 计算已知方位距离的目标点
+/**
+ * 计算已知方位距离的目标点
  * @param coordinates 起点坐标 WGS84 EPSG:4326
  * @param distance 距离，单位为米
  * @param azimuth 方位角，单位为度
  * @returns 目标点坐标 WGS84 EPSG:4326
  */
-export declare const getDestinationPoint: (coordinates: Coordinate, distance: number, azimuth: number) => Coordinate;
-/** 计算线段的长度
+export declare function getDestinationPoint(coordinates: Coordinate, distance: number, azimuth: number): Coordinate;
+/**
+ * 计算线段的长度
  * @param coordinates 线段坐标 WGS84 EPSG:4326
  * @returns 线段长度，单位为米
  */
-export declare const getLineLength: (coordinates: Coordinate[]) => number;
+export declare function getLineLength(coordinates: Coordinate[]): number;
 /** 计算面积 */
-export declare const getArea: (coordinates: Coordinate[][]) => number;
+export declare function getArea(coordinates: Coordinate[][]): number;
 /** 计算2点之间的角度 */
-export declare const getAngle: (start: Coordinate, end: Coordinate) => number;
+export declare function getAngle(start: Coordinate, end: Coordinate): number;
 /** 计算2点的中心点 */
-export declare const getCenter: (start: Coordinate, end: Coordinate) => Coordinate;
+export declare function getCenter(start: Coordinate, end: Coordinate): Coordinate;
 /** 计算Extent中心点 */
-export declare const getExtentCenter: (extent: Extent) => Coordinate;
+export declare function getExtentCenter(extent: Extent): Coordinate;

package/es/utils/calculate/index.mjs

@@ -1,14 +1,29 @@
-import { destination as r, lineString as o, length as i, area as g, polygon as s, bearing as u, midpoint as c } from "@turf/turf";
-import { toTurfAngle as m, toOlAngle as a } from "../format/index.mjs";
-const f = (t, e, n) => r(t, e, m(n), { units: "meters" }).geometry.coordinates, A = (t) => {
-  const e = o(t);
-  return i(e, { units: "meters" });
-}, y = (t) => g(s(t)), L = (t, e) => a(u(t, e)), l = (t, e) => c(t, e).geometry.coordinates, h = (t) => l([t[0], t[1]], [t[2], t[3]]);
+import { destination as r, lineString as o, length as i, area as g, polygon as u, bearing as f, midpoint as c } from "@turf/turf";
+import { toTurfAngle as m, toOlAngle as s } from "../format/index.mjs";
+function d(n, t, e) {
+  return r(n, t, m(e), { units: "meters" }).geometry.coordinates;
+}
+function A(n) {
+  const t = o(n);
+  return i(t, { units: "meters" });
+}
+function y(n) {
+  return g(u(n));
+}
+function L(n, t) {
+  return s(f(n, t));
+}
+function a(n, t) {
+  return c(n, t).geometry.coordinates;
+}
+function h(n) {
+  return a([n[0], n[1]], [n[2], n[3]]);
+}
 export {
   L as getAngle,
   y as getArea,
-  l as getCenter,
-  f as getDestinationPoint,
+  a as getCenter,
+  d as getDestinationPoint,
   h as getExtentCenter,
   A as getLineLength
 };

package/es/utils/distance/index.d.ts

@@ -1,4 +1,4 @@
 /** 公里转海里 */
-export declare const kmToNauticalMiles: (km: number) => number;
+export declare function kmToNauticalMiles(km: number): number;
 /** 海里转公里 */
-export declare const nauticalMilesToKm: (nauticalMiles: number) => number;
+export declare function nauticalMilesToKm(nauticalMiles: number): number;

package/es/utils/distance/index.mjs

@@ -1,6 +1,11 @@
 import { ONE_NM as e } from "../../constants/distance.mjs";
-const r = (t) => t * 1e3 / e, i = (t) => t * e / 1e3;
+function n(t) {
+  return t * 1e3 / e;
+}
+function o(t) {
+  return t * e / 1e3;
+}
 export {
-  r as kmToNauticalMiles,
-  i as nauticalMilesToKm
+  n as kmToNauticalMiles,
+  o as nauticalMilesToKm
 };

package/es/utils/feature/index.d.ts

@@ -1,26 +1,26 @@
-import { Feature } from 'ol';
-import { Circle, Geometry, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon } from 'ol/geom';
-import { StyleOptions } from '../style';
-import { Style } from 'ol/style';
 import { Coordinate } from 'ol/coordinate';
-export type FeatureOptions = {
+import { Geometry, Circle, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon } from 'ol/geom';
+import { Style } from 'ol/style';
+import { StyleOptions } from '../style';
+import { Feature } from 'ol';
+export interface FeatureOptions {
     style?: Style;
     styleOptions?: StyleOptions;
     geometry?: Geometry;
     [key: string]: any;
-};
-export declare const createPoint: (coordinates: Coordinate) => Point;
-export declare const createLineString: (coordinates: Coordinate[]) => LineString;
-export declare const createPolygon: (coordinates: Coordinate[][]) => Polygon;
-export declare const createCircle: (center: Coordinate, radius: number) => Circle;
-export declare const createMultiPoint: (coordinates: Coordinate[]) => MultiPoint;
-export declare const createMultiLineString: (coordinates: Coordinate[][]) => MultiLineString;
-export declare const createMultiPolygon: (coordinates: Coordinate[][][]) => MultiPolygon;
-export declare const createFeature: (options?: FeatureOptions) => Feature<Geometry>;
-export declare const createPointFeature: (coordinates: Coordinate, options?: FeatureOptions) => Feature<Point>;
-export declare const createLineStringFeature: (coordinates: Coordinate[], options?: FeatureOptions) => Feature<LineString>;
-export declare const createPolygonFeature: (coordinates: Coordinate[][], options?: FeatureOptions) => Feature<Polygon>;
-export declare const createCircleFeature: (center: Coordinate, radius: number, options?: FeatureOptions) => Feature<Circle>;
-export declare const createMultiPointFeature: (coordinates: Coordinate[], options?: FeatureOptions) => Feature<MultiPoint>;
-export declare const createMultiLineStringFeature: (coordinates: Coordinate[][], options?: FeatureOptions) => Feature<MultiLineString>;
-export declare const createMultiPolygonFeature: (coordinates: Coordinate[][][], options?: FeatureOptions) => Feature<MultiPolygon>;
+}
+export declare function createPoint(coordinates: Coordinate): Point;
+export declare function createLineString(coordinates: Coordinate[]): LineString;
+export declare function createPolygon(coordinates: Coordinate[][]): Polygon;
+export declare function createCircle(center: Coordinate, radius: number): Circle;
+export declare function createMultiPoint(coordinates: Coordinate[]): MultiPoint;
+export declare function createMultiLineString(coordinates: Coordinate[][]): MultiLineString;
+export declare function createMultiPolygon(coordinates: Coordinate[][][]): MultiPolygon;
+export declare function createFeature(options?: FeatureOptions): Feature<Geometry>;
+export declare function createPointFeature(coordinates: Coordinate, options?: FeatureOptions): Feature<Point>;
+export declare function createLineStringFeature(coordinates: Coordinate[], options?: FeatureOptions): Feature<LineString>;
+export declare function createPolygonFeature(coordinates: Coordinate[][], options?: FeatureOptions): Feature<Polygon>;
+export declare function createCircleFeature(center: Coordinate, radius: number, options?: FeatureOptions): Feature<Circle>;
+export declare function createMultiPointFeature(coordinates: Coordinate[], options?: FeatureOptions): Feature<MultiPoint>;
+export declare function createMultiLineStringFeature(coordinates: Coordinate[][], options?: FeatureOptions): Feature<MultiLineString>;
+export declare function createMultiPolygonFeature(coordinates: Coordinate[][][], options?: FeatureOptions): Feature<MultiPolygon>;

package/es/utils/feature/index.mjs

@@ -1,69 +1,97 @@
-import { Feature as c } from "ol";
-import { Point as i, LineString as u, Polygon as s, Circle as a, MultiPoint as l, MultiLineString as g, MultiPolygon as y } from "ol/geom";
-import { createStyle as m } from "../style/index.mjs";
-const P = (e) => new i(e), F = (e) => new u(e), M = (e) => new s(e), w = (e, t) => new a(e, t), S = (e) => new l(e), p = (e) => new g(e), L = (e) => new y(e), n = (e) => {
-  const { styleOptions: t, ...r } = e ?? {}, o = t ? m(t) : r.style;
-  return new c({
-    ...r,
+import { Feature as i } from "ol";
+import { Point as u, LineString as c, Polygon as a, Circle as l, MultiPoint as f, MultiLineString as g, MultiPolygon as y } from "ol/geom";
+import { createStyle as s } from "../style/index.mjs";
+function m(e) {
+  return new u(e);
+}
+function P(e) {
+  return new c(e);
+}
+function F(e) {
+  return new a(e);
+}
+function M(e, t) {
+  return new l(e, t);
+}
+function w(e) {
+  return new f(e);
+}
+function S(e) {
+  return new g(e);
+}
+function p(e) {
+  return new y(e);
+}
+function r(e) {
+  const { styleOptions: t, ...n } = e ?? {}, o = t ? s(t) : n.style;
+  return new i({
+    ...n,
     style: o
   });
-}, b = (e, t) => {
-  const r = P(e);
-  return n({
+}
+function b(e, t) {
+  const n = m(e);
+  return r({
     ...t,
-    geometry: r
+    geometry: n
   });
-}, d = (e, t) => {
-  const r = F(e);
-  return n({
+}
+function d(e, t) {
+  const n = P(e);
+  return r({
     ...t,
-    geometry: r
+    geometry: n
   });
-}, h = (e, t) => {
-  const r = M(e);
-  return n({
+}
+function h(e, t) {
+  const n = F(e);
+  return r({
     ...t,
-    geometry: r
+    geometry: n
   });
-}, j = (e, t, r) => {
-  const o = w(e, t);
-  return n({
-    ...r,
+}
+function j(e, t, n) {
+  const o = M(e, t);
+  return r({
+    ...n,
     geometry: o
   });
-}, k = (e, t) => {
-  const r = S(e);
-  return n({
+}
+function k(e, t) {
+  const n = w(e);
+  return r({
     ...t,
-    geometry: r
+    geometry: n
   });
-}, q = (e, t) => {
-  const r = p(e);
-  return n({
+}
+function q(e, t) {
+  const n = S(e);
+  return r({
     ...t,
-    geometry: r
+    geometry: n
   });
-}, v = (e, t) => {
-  const r = L(e);
-  return n({
+}
+function v(e, t) {
+  const n = p(e);
+  return r({
     ...t,
-    geometry: r
+    geometry: n
   });
-};
+}
 export {
-  w as createCircle,
+  M as createCircle,
   j as createCircleFeature,
-  n as createFeature,
-  F as createLineString,
+  r as createFeature,
+  P as createLineString,
   d as createLineStringFeature,
-  p as createMultiLineString,
+  S as createMultiLineString,
   q as createMultiLineStringFeature,
-  S as createMultiPoint,
+  w as createMultiPoint,
   k as createMultiPointFeature,
-  L as createMultiPolygon,
+  p as createMultiPolygon,
   v as createMultiPolygonFeature,
-  P as createPoint,
+  m as createPoint,
   b as createPointFeature,
-  M as createPolygon,
+  F as createPolygon,
   h as createPolygonFeature
 };

package/es/utils/format/index.d.ts

@@ -1,4 +1,4 @@
 /** 任意角度转换为 0-360 */
-export declare const toOlAngle: (angle: number) => number;
+export declare function toOlAngle(angle: number): number;
 /** 任意角度转换为 -180-180 */
-export declare const toTurfAngle: (angle: number) => number;
+export declare function toTurfAngle(angle: number): number;

package/es/utils/format/index.mjs

@@ -1,4 +1,9 @@
-const t = (r) => r < 0 ? t(r + 360) : r > 360 ? t(r - 360) : r, u = (r) => r < -180 ? u(r + 360) : r > 180 ? u(r - 360) : r;
+function t(r) {
+  return r < 0 ? t(r + 360) : r > 360 ? t(r - 360) : r;
+}
+function u(r) {
+  return r < -180 ? u(r + 360) : r > 180 ? u(r - 360) : r;
+}
 export {
   t as toOlAngle,
   u as toTurfAngle

package/es/utils/index.d.ts

@@ -1,8 +1,8 @@
-export * from './layer';
 export * from './calculate';
 export * from './distance';
+export * from './feature';
 export * from './format';
+export * from './layer';
 export * from './projection';
 export * from './realCircle';
 export * from './style';
-export * from './feature';

package/es/utils/layer/index.d.ts

@@ -1,11 +1,11 @@
-import { Tile as TileLayer } from 'ol/layer';
+import { Feature } from 'ol';
+import { Geometry } from 'ol/geom';
 import { ProjectionLike } from 'ol/proj';
+import { StyleOptions } from '../style';
+import { Tile as TileLayer } from 'ol/layer';
+import { default as VectorLayer } from 'ol/layer/Vector';
 import { BingMaps, OSM, XYZ } from 'ol/source';
 import { default as VectorSource } from 'ol/source/Vector';
-import { default as VectorLayer } from 'ol/layer/Vector';
-import { Geometry } from 'ol/geom';
-import { Feature } from 'ol';
-import { StyleOptions } from '../style';
 /**
  * 天地图类型
  * vec: 矢量底图
@@ -17,35 +17,35 @@ import { StyleOptions } from '../style';
  * ibo: 全球境界
  */
 export type T_MAP_TYPE = 'vec' | 'cva' | 'img' | 'cia' | 'ter' | 'cta' | 'ibo';
-export declare const getTianDiTuUrl: (data: {
+export declare function getTianDiTuUrl(data: {
     url?: string;
     type: T_MAP_TYPE;
     projection: ProjectionLike;
     key: string;
-}) => string;
-export declare const getTianDiTuLayer: (data: {
+}): string;
+export declare function getTianDiTuLayer(data: {
     url?: string;
     projection: ProjectionLike;
     zIndex?: number;
     key: string;
     type: T_MAP_TYPE;
     className?: string;
-}) => TileLayer<XYZ>;
-export declare const getBingLayer: ({ name, zIndex, key, className, }: {
+}): TileLayer<XYZ>;
+export declare function getBingLayer({ name, zIndex, key, className, }: {
     name: string;
     zIndex?: number;
     key: string;
     className?: string;
-}) => TileLayer<BingMaps>;
-export declare const getOSMLayer: (data?: {
+}): TileLayer<BingMaps>;
+export declare function getOSMLayer(data?: {
     zIndex?: number;
     className?: string;
-}) => TileLayer<OSM>;
+}): TileLayer<OSM>;
 export type _VectorLayerOptions = ConstructorParameters<typeof VectorLayer>[0];
 export type VectorLayerOptions = _VectorLayerOptions & {
     styleOptions?: StyleOptions;
 };
-export declare const createVectorLayer: <T extends Geometry = Geometry>(options?: VectorLayerOptions) => {
+export declare function createVectorLayer<T extends Geometry = Geometry>(options?: VectorLayerOptions): {
     source: VectorSource<Feature<T>>;
     layer: VectorLayer<VectorSource<import('ol/Feature').FeatureLike>, import('ol/Feature').FeatureLike>;
 };