@planet/maps 11.0.0 → 11.1.0

package/internal/render.js

@@ -1,18 +1,24 @@
+import OLMap from 'ol/Map.js';
+import {unByKey} from 'ol/Observable.js';
 import Overlay from 'ol/Overlay.js';
 import View from 'ol/View.js';
 import Control from 'ol/control/Control.js';
 import Interaction from 'ol/interaction/Interaction.js';
 import BaseLayer from 'ol/layer/Base.js';
 import GroupLayer from 'ol/layer/Group.js';
+import Layer from 'ol/layer/Layer.js';
 import Source from 'ol/source/Source.js';
+import Vector from 'ol/source/Vector.js';
 import ReactReconciler from 'react-reconciler';
 import {
   ConcurrentRoot,
   DefaultEventPriority,
+  //@ts-ignore (TODO: remove after https://github.com/DefinitelyTyped/DefinitelyTyped/pull/72046 is released)
   NoEventPriority,
 } from 'react-reconciler/constants.js';
 import {CONTROL, INTERACTION, LAYER, OVERLAY, SOURCE, VIEW} from './config.js';
 import {
+  arrayEquals,
   prepareControlUpdate,
   prepareInteractionUpdate,
   prepareLayerUpdate,
@@ -25,14 +31,23 @@ import {
 const listenerRegex = /^on([A-Z].*)/;
 const listenerColonRegex = /^onChange-/;
 
+/**
+ * @param {string} str A string.
+ */
 function upperFirst(str) {
   return str[0].toUpperCase() + str.slice(1);
 }
 
+/**
+ * @param {string} str A string.
+ */
 function setterName(str) {
   return 'set' + upperFirst(str);
 }
 
+/**
+ * @type {Object<string, boolean>}
+ */
 const knownTypes = {
   [VIEW]: true,
   [OVERLAY]: true,
@@ -42,30 +57,11 @@ const knownTypes = {
   [SOURCE]: true,
 };
 
+const customViewChangeEventType = 'custom-change';
+
 /**
- * @param {Array} a1 An array.
- * @param {Array} a2 An array.
- * @return {boolean} All elements in the array are the same;
+ * @type {import('./update.js').Updater}
  */
-function arrayEquals(a1, a2) {
-  if (!a1 || !a2) {
-    return false;
-  }
-  const len1 = a1.length;
-  const len2 = a2.length;
-  if (len1 !== len2) {
-    return false;
-  }
-  for (let i = 0; i < len1; i += 1) {
-    const v1 = a1[i];
-    const v2 = a2[i];
-    if (v1 !== v2) {
-      return false;
-    }
-  }
-  return true;
-}
-
 export function updateInstanceFromProps(instance, type, oldProps, newProps) {
   for (const key in newProps) {
     if (reservedProps[key]) {
@@ -79,10 +75,15 @@ export function updateInstanceFromProps(instance, type, oldProps, newProps) {
 
     if (listenerRegex.test(key)) {
       const listener = newProps[key];
-      const eventType = key
+      let eventType = key
         .replace(listenerColonRegex, 'onChange:')
         .replace(listenerRegex, '$1')
         .toLowerCase();
+
+      // special handling for view change
+      if (instance instanceof View && eventType === 'change') {
+        eventType = customViewChangeEventType;
+      }
       instance.on(eventType, listener);
 
       const oldListener = oldProps[key];
@@ -105,31 +106,46 @@ export function updateInstanceFromProps(instance, type, oldProps, newProps) {
       continue;
     }
 
-    if (key === 'features' && typeof instance.addFeatures === 'function') {
-      // TODO: there is likely a smarter way to diff features
-      instance.clear(true);
-      instance.addFeatures(newValue);
-      continue;
+    if (instance instanceof Vector) {
+      if (key === 'features') {
+        // TODO: there is likely a smarter way to diff features
+        instance.clear(true);
+        instance.addFeatures(newValue);
+        continue;
+      }
     }
 
-    if (
-      key === 'interactions' &&
-      typeof instance.addInteraction === 'function'
-    ) {
-      instance.getInteractions().clear();
-      newValue.forEach(interaction => instance.addInteraction(interaction));
-      continue;
-    }
-    if (key === 'controls' && typeof instance.addControl === 'function') {
-      instance.getControls().clear();
-      newValue.forEach(control => instance.addControl(control));
-      continue;
+    if (instance instanceof OLMap) {
+      if (key === 'interactions') {
+        const interactions = /** @type {Array<Interaction>} */ (newValue);
+        instance.getInteractions().clear();
+        interactions.forEach(interaction =>
+          instance.addInteraction(interaction),
+        );
+        continue;
+      }
+      if (key === 'controls') {
+        const controls = /** @type {Array<Control>} */ (newValue);
+        instance.getControls().clear();
+        controls.forEach(control => instance.addControl(control));
+        continue;
+      }
     }
 
     throw new Error(`Cannot update '${key}' property`);
   }
 }
 
+/**
+ * @typedef {Object} InstanceProps
+ * @property {new(options: any) => any} cls A class.
+ * @property {any} [options] The options.
+ */
+
+/**
+ * @param {string} type The string type.
+ * @param {InstanceProps} The instance props.
+ */
 function createInstance(type, {cls: Constructor, ...props}) {
   if (!knownTypes[type]) {
     throw new Error(`Unsupported element type: ${type}`);
@@ -147,9 +163,19 @@ function createTextInstance() {
   throw new Error('Cannot add text to the map');
 }
 
+/**
+ * @param {OLMap} map The map.
+ * @param {any} child The child.
+ */
 function appendChildToContainer(map, child) {
   if (child instanceof View) {
+    const key = map.on('moveend', () => {
+      child.dispatchEvent(customViewChangeEventType);
+    });
     map.setView(child);
+    map.on('change:view', () => {
+      unByKey(key);
+    });
     return;
   }
   if (child instanceof Overlay) {
@@ -171,9 +197,13 @@ function appendChildToContainer(map, child) {
   throw new Error(`Cannot add child to the map: ${child}`);
 }
 
+/**
+ * @param {any} parent The parent.
+ * @param {any} child The child.
+ */
 function appendChild(parent, child) {
   if (child instanceof Source) {
-    if (!(parent instanceof BaseLayer)) {
+    if (!(parent instanceof Layer)) {
       throw new Error(`Cannot add source to ${parent}`);
     }
     parent.setSource(child);
@@ -187,6 +217,9 @@ function appendChild(parent, child) {
   throw new Error(`Cannot add ${child} to ${parent}`);
 }
 
+/**
+ * @type {Object<string, import('./update.js').Updater>}
+ */
 const updaters = {
   [VIEW]: prepareViewUpdate,
   [OVERLAY]: prepareOverlayUpdate,
@@ -196,6 +229,12 @@ const updaters = {
   [SOURCE]: prepareSourceUpdate,
 };
 
+/**
+ * @param {any} instance The instance to update.
+ * @param {string} type The string type.
+ * @param {Object<string, any>} oldProps The old props.
+ * @param {Object<string, any>} newProps The new props.
+ */
 function prepareUpdate(instance, type, oldProps, newProps) {
   const updater = updaters[type];
   if (!updater) {
@@ -204,13 +243,21 @@ function prepareUpdate(instance, type, oldProps, newProps) {
   return updater(instance, type, oldProps, newProps);
 }
 
+/**
+ * @type {import('./update.js').Updater}
+ */
 function commitUpdate(instance, type, oldProps, newProps) {
   updateInstanceFromProps(instance, type, oldProps, newProps);
 }
 
+/**
+ * @param {OLMap} map The map.
+ * @param {any} child The object to remove from the map.
+ */
 function removeChildFromContainer(map, child) {
   if (child instanceof View) {
-    map.setView(child);
+    // @ts-ignore (remove when https://github.com/openlayers/openlayers/pull/16691 is released)
+    map.setView(null);
     return;
   }
   if (child instanceof Overlay) {
@@ -232,6 +279,10 @@ function removeChildFromContainer(map, child) {
   throw new Error(`Cannot remove child from the map: ${child}`);
 }
 
+/**
+ * @param {any} parent The parent object.
+ * @param {any} child The child object.
+ */
 function removeChild(parent, child) {
   // this happens with group layers
   if (child instanceof BaseLayer && parent.getLayers) {
@@ -241,12 +292,21 @@ function removeChild(parent, child) {
   throw new Error(`TODO: implement removeChild for ${parent} and ${child}`);
 }
 
+/**
+ * @param {OLMap} map The map.
+ */
 function clearContainer(map) {
   map.getLayers().clear();
   // Need to leave the default controls and interactions.
   // TODO: determine when this gets called.
 }
 
+/**
+ * @template {any} T
+ * @param {import("ol/Collection.js").default<T>} collection A collection.
+ * @param {T} child The child to insert.
+ * @param {T} beforeChild The insertion point.
+ */
 function insertInCollection(collection, child, beforeChild) {
   const index = collection.getArray().indexOf(beforeChild);
   if (index < 0) {
@@ -256,9 +316,20 @@ function insertInCollection(collection, child, beforeChild) {
   }
 }
 
+/**
+ * @param {OLMap} map The map.
+ * @param {any} child The child to insert.
+ * @param {any} beforeChild The insertion point.
+ */
 function insertInContainerBefore(map, child, beforeChild) {
   if (child instanceof View) {
+    const key = map.on('moveend', () => {
+      child.dispatchEvent(customViewChangeEventType);
+    });
     map.setView(child);
+    map.on('change:view', () => {
+      unByKey(key);
+    });
     return;
   }
   let collection;
@@ -276,6 +347,11 @@ function insertInContainerBefore(map, child, beforeChild) {
   }
 }
 
+/**
+ * @param {any} parent The parent.
+ * @param {any} child The child to insert.
+ * @param {any} beforeChild The insertion point.
+ */
 function insertBefore(parent, child, beforeChild) {
   if (child instanceof BaseLayer && parent instanceof GroupLayer) {
     insertInCollection(parent.getLayers(), child, beforeChild);
@@ -308,6 +384,7 @@ const reconciler = ReactReconciler({
     return null;
   },
 
+  //@ts-ignore
   shouldAttemptEagerTransition() {
     return false;
   },
@@ -330,6 +407,9 @@ const reconciler = ReactReconciler({
     return null;
   },
 
+  /**
+   * @param {number} newPriority The new priority.
+   */
   setCurrentUpdatePriority(newPriority) {
     currentUpdatePriority = newPriority;
   },
@@ -378,8 +458,15 @@ const reconciler = ReactReconciler({
   detachDeletedInstance() {},
 });
 
+/**
+ * @type {Map<any, ReactReconciler.OpaqueRoot>}
+ */
 const roots = new Map();
 
+/**
+ * @param {React.ReactNode} element The element to render.
+ * @param {any} container The container.
+ */
 export function render(element, container) {
   let root = roots.get(container);
   if (!root) {

package/internal/update.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @typedef {function(any, string, Object<string, any>, Object<string, any>): any} Updater
+ */
+/**
+ * @param {Array<any>} [a1] An array.
+ * @param {Array<any>} [a2] An array.
+ * @return {boolean} All elements in the array are the same;
+ */
+export function arrayEquals(a1?: Array<any>, a2?: Array<any>): boolean;
+/**
+ * @param {import("ol/View.js").default} view The view.
+ * @param {string} type The string type.
+ * @param {Object<string, any>} oldProps The old props.
+ * @param {Object<string, any>} newProps The new props.
+ */
+export function prepareViewUpdate(view: import("ol/View.js").default, type: string, oldProps: {
+    [x: string]: any;
+}, newProps: {
+    [x: string]: any;
+}): {
+    [x: string]: any;
+} | null;
+/**
+ * @type {Object<string, boolean>}
+ */
+export const reservedProps: {
+    [x: string]: boolean;
+};
+export type Updater = (arg0: any, arg1: string, arg2: {
+    [x: string]: any;
+}, arg3: {
+    [x: string]: any;
+}) => any;
+declare function prepareGenericUpdate(arg0: any, arg1: string, arg2: {
+    [x: string]: any;
+}, arg3: {
+    [x: string]: any;
+}): any;
+export { prepareGenericUpdate as prepareControlUpdate, prepareGenericUpdate as prepareInteractionUpdate, prepareGenericUpdate as prepareLayerUpdate, prepareGenericUpdate as prepareOverlayUpdate, prepareGenericUpdate as prepareSourceUpdate };
+//# sourceMappingURL=update.d.ts.map

package/internal/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["update.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,iCAJW,KAAK,CAAC,GAAG,CAAC,OACV,KAAK,CAAC,GAAG,CAAC,GACT,OAAO,CAkBlB;AAYD;;;;;GAKG;AACH,wCALW,OAAO,YAAY,EAAE,OAAO,QAC5B,MAAM;;;;;;SA2DhB;AAvED;;GAEG;AACH;;EAKE;sBAlCW,CAAS,IAAG,EAAH,GAAG,EAAE,IAAM,EAAN,MAAM,EAAE,IAAmB,EAAnB;QAAO,MAAM,GAAE,GAAG;CAAC,EAAE,IAAmB,EAAnB;QAAO,MAAM,GAAE,GAAG;CAAC,KAAG,GAAG;AAApE,4CAAS,GAAG,QAAE,MAAM;;;;IAA6C,GAAG,CAAA"}

package/internal/update.js

@@ -1,15 +1,33 @@
-function arrayEquals(a, b) {
-  if (a.length !== b.length) {
+/**
+ * @typedef {function(any, string, Object<string, any>, Object<string, any>): any} Updater
+ */
+
+/**
+ * @param {Array<any>} [a1] An array.
+ * @param {Array<any>} [a2] An array.
+ * @return {boolean} All elements in the array are the same;
+ */
+export function arrayEquals(a1, a2) {
+  if (!a1 || !a2) {
+    return false;
+  }
+  const len = a1.length;
+  if (len !== a2.length) {
     return false;
   }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
+  for (let i = 0; i < len; i += 1) {
+    const v1 = a1[i];
+    const v2 = a2[i];
+    if (v1 !== v2) {
       return false;
     }
   }
   return true;
 }
 
+/**
+ * @type {Object<string, boolean>}
+ */
 export const reservedProps = {
   children: true,
   cls: true,
@@ -17,10 +35,19 @@ export const reservedProps = {
   ref: true, // TODO: deal with changing ref
 };
 
+/**
+ * @param {import("ol/View.js").default} view The view.
+ * @param {string} type The string type.
+ * @param {Object<string, any>} oldProps The old props.
+ * @param {Object<string, any>} newProps The new props.
+ */
 export function prepareViewUpdate(view, type, oldProps, newProps) {
   if (view.getAnimating()) {
     return null;
   }
+  /**
+   * @type {Object<string, any>}
+   */
   const payload = {};
   let needsUpdate = false;
   for (const key in newProps) {
@@ -71,7 +98,13 @@ export function prepareViewUpdate(view, type, oldProps, newProps) {
   return payload;
 }
 
+/**
+ * @type {Updater}
+ */
 function prepareGenericUpdate(instance, type, oldProps, newProps) {
+  /**
+   * @type {Object<string, any>}
+   */
   const payload = {};
   let needsUpdate = false;
   for (const key in newProps) {

package/layer/Base.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {Object} BaseProps
+ * @property {ConstructorParameters<typeof OLBase>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+/**
+ * @param {BaseProps | Object<string, any>} props The layer props.
+ */
+export default function Base({ children, ...props }: BaseProps | {
+    [x: string]: any;
+}): import("react").ReactElement<{
+    /**
+     * The layer options.
+     */
+    options?: import("ol/layer/Base.js").Options | undefined;
+    cls: typeof OLBase;
+}, string | import("react").JSXElementConstructor<any>>;
+export type BaseProps = {
+    /**
+     * The layer options.
+     */
+    options?: import("ol/layer/Base.js").Options | undefined;
+    /**
+     * The layer source.
+     */
+    children: React.ReactNode;
+};
+import OLBase from 'ol/layer/Base.js';
+//# sourceMappingURL=Base.d.ts.map

package/layer/Base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Base.d.ts","sourceRoot":"","sources":["Base.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AAEH;;GAEG;AACH,qDAFW,SAAS,GAAG;QAAO,MAAM,GAAE,GAAG;CAAC;;;;;;wDAIzC;;;;;;;;;cARa,KAAK,CAAC,SAAS;;mBANV,kBAAkB"}

package/layer/Base.js

@@ -15,13 +15,17 @@
  * limitations under the License.
  */
 import OLBase from 'ol/layer/Base.js';
-import propTypes from 'prop-types';
 import {createElement} from 'react';
 
+/**
+ * @typedef {Object} BaseProps
+ * @property {ConstructorParameters<typeof OLBase>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+
+/**
+ * @param {BaseProps | Object<string, any>} props The layer props.
+ */
 export default function Base({children, ...props}) {
   return createElement('layer', {cls: OLBase, ...props}, children);
 }
-
-Base.propTypes = {
-  children: propTypes.node,
-};

package/layer/BaseImage.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {Object} BaseImageProps
+ * @property {ConstructorParameters<typeof OLBaseImage>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+/**
+ * @param {BaseImageProps | Object<string, any>} props The layer props.
+ */
+export default function BaseImage({ children, ...props }: BaseImageProps | {
+    [x: string]: any;
+}): import("react").ReactElement<{
+    /**
+     * The layer options.
+     */
+    options?: ConstructorParameters<typeof OLBaseImage>[0];
+    cls: typeof OLBaseImage;
+}, string | import("react").JSXElementConstructor<any>>;
+export type BaseImageProps = {
+    /**
+     * The layer options.
+     */
+    options?: ConstructorParameters<typeof OLBaseImage>[0];
+    /**
+     * The layer source.
+     */
+    children: React.ReactNode;
+};
+import OLBaseImage from 'ol/layer/BaseImage.js';
+//# sourceMappingURL=BaseImage.d.ts.map

package/layer/BaseImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseImage.d.ts","sourceRoot":"","sources":["BaseImage.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AAEH;;GAEG;AACH,0DAFW,cAAc,GAAG;QAAO,MAAM,GAAE,GAAG;CAAC;;;;cALjC,qBAAqB,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC;;wDASzD;;;;;cATa,qBAAqB,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC;;;;cAC5C,KAAK,CAAC,SAAS;;wBANL,uBAAuB"}

package/layer/BaseImage.js

@@ -15,13 +15,17 @@
  * limitations under the License.
  */
 import OLBaseImage from 'ol/layer/BaseImage.js';
-import propTypes from 'prop-types';
 import {createElement} from 'react';
 
+/**
+ * @typedef {Object} BaseImageProps
+ * @property {ConstructorParameters<typeof OLBaseImage>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+
+/**
+ * @param {BaseImageProps | Object<string, any>} props The layer props.
+ */
 export default function BaseImage({children, ...props}) {
   return createElement('layer', {cls: OLBaseImage, ...props}, children);
 }
-
-BaseImage.propTypes = {
-  children: propTypes.node,
-};

package/layer/BaseTile.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {Object} BaseTileProps
+ * @property {ConstructorParameters<typeof OLBaseTile>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+/**
+ * @param {BaseTileProps | Object<string, any>} props The layer props.
+ */
+export default function BaseTile({ children, ...props }: BaseTileProps | {
+    [x: string]: any;
+}): import("react").ReactElement<{
+    /**
+     * The layer options.
+     */
+    options?: ConstructorParameters<typeof OLBaseTile>[0];
+    cls: typeof OLBaseTile;
+}, string | import("react").JSXElementConstructor<any>>;
+export type BaseTileProps = {
+    /**
+     * The layer options.
+     */
+    options?: ConstructorParameters<typeof OLBaseTile>[0];
+    /**
+     * The layer source.
+     */
+    children: React.ReactNode;
+};
+import OLBaseTile from 'ol/layer/BaseTile.js';
+//# sourceMappingURL=BaseTile.d.ts.map

package/layer/BaseTile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseTile.d.ts","sourceRoot":"","sources":["BaseTile.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AAEH;;GAEG;AACH,yDAFW,aAAa,GAAG;QAAO,MAAM,GAAE,GAAG;CAAC;;;;cALhC,qBAAqB,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;;wDASxD;;;;;cATa,qBAAqB,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;;;;cAC3C,KAAK,CAAC,SAAS;;uBANN,sBAAsB"}

package/layer/BaseTile.js

@@ -15,13 +15,17 @@
  * limitations under the License.
  */
 import OLBaseTile from 'ol/layer/BaseTile.js';
-import propTypes from 'prop-types';
 import {createElement} from 'react';
 
+/**
+ * @typedef {Object} BaseTileProps
+ * @property {ConstructorParameters<typeof OLBaseTile>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+
+/**
+ * @param {BaseTileProps | Object<string, any>} props The layer props.
+ */
 export default function BaseTile({children, ...props}) {
   return createElement('layer', {cls: OLBaseTile, ...props}, children);
 }
-
-BaseTile.propTypes = {
-  children: propTypes.node,
-};

package/layer/BaseVector.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @typedef {Object} BaseVectorProps
+ * @property {ConstructorParameters<typeof OLBaseVector>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+/**
+ * @param {BaseVectorProps | Object<string, any>} props The layer props.
+ */
+export default function BaseVector({ children, ...props }: BaseVectorProps | {
+    [x: string]: any;
+}): import("react").ReactElement<{
+    /**
+     * The layer options.
+     */
+    options?: ConstructorParameters<typeof OLBaseVector>[0];
+    cls: typeof OLBaseVector;
+}, string | import("react").JSXElementConstructor<any>>;
+export type BaseVectorProps = {
+    /**
+     * The layer options.
+     */
+    options?: ConstructorParameters<typeof OLBaseVector>[0];
+    /**
+     * The layer source.
+     */
+    children: React.ReactNode;
+};
+import OLBaseVector from 'ol/layer/BaseVector.js';
+//# sourceMappingURL=BaseVector.d.ts.map

package/layer/BaseVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseVector.d.ts","sourceRoot":"","sources":["BaseVector.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AAEH;;GAEG;AACH,2DAFW,eAAe,GAAG;QAAO,MAAM,GAAE,GAAG;CAAC;;;;cALlC,qBAAqB,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;;wDAS1D;;;;;cATa,qBAAqB,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;;;;cAC7C,KAAK,CAAC,SAAS;;yBANJ,wBAAwB"}

package/layer/BaseVector.js

@@ -15,13 +15,17 @@
  * limitations under the License.
  */
 import OLBaseVector from 'ol/layer/BaseVector.js';
-import propTypes from 'prop-types';
 import {createElement} from 'react';
 
+/**
+ * @typedef {Object} BaseVectorProps
+ * @property {ConstructorParameters<typeof OLBaseVector>[0]} [options] The layer options.
+ * @property {React.ReactNode} children The layer source.
+ */
+
+/**
+ * @param {BaseVectorProps | Object<string, any>} props The layer props.
+ */
 export default function BaseVector({children, ...props}) {
   return createElement('layer', {cls: OLBaseVector, ...props}, children);
 }
-
-BaseVector.propTypes = {
-  children: propTypes.node,
-};