@emuanalytics/flow-rdf-core 4.0.4 → 4.0.5

package/dist/lib/map-style/map-data-source.mjs

@@ -0,0 +1,192 @@
+import * as mobx from 'mobx';
+import { isIn, isString, isStringFull, isNil, isURL } from '../utils/type-checks.mjs';
+import { FlowCoreError } from '../errors/flow-error.mjs';
+import { ReactiveExpression } from '../expressions/reactive-expression.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _MapDataSource = class _MapDataSource {
+  constructor(options) {
+    __publicField(this, "_options");
+    __publicField(this, "_srcExpression", null);
+    __publicField(this, "_parameters", {});
+    __publicField(this, "_state", null);
+    this._options = {
+      ..._MapDataSource.defaultOptions,
+      ...options
+    };
+    if (!isIn(options.type, ["vector", "geojson", "raster"])) {
+      throw new FlowCoreError(`${this.formattedName()}: unrecognized type '${options.type}'`);
+    }
+    this.setSrcExpression(options.src);
+    mobx.makeObservable(
+      this,
+      {
+        //observable
+        _options: mobx.observable.shallow,
+        _srcExpression: mobx.observable,
+        _parameters: mobx.observable,
+        //computed
+        dataSourceSpecification: mobx.computed,
+        // actions
+        bindState: mobx.action,
+        setSrc: mobx.action,
+        setParameter: mobx.action
+      },
+      { name: this.formattedName(options.id) }
+    );
+  }
+  get id() {
+    return this._options.id;
+  }
+  get type() {
+    return this._options.type;
+  }
+  get featureId() {
+    return this._options.featureId;
+  }
+  get dataSourceSpecification() {
+    let src = this._srcExpression ? mobx.toJS(this._srcExpression.value) : this._options.src;
+    if (isString(src)) {
+      src = this.expandSrc(src, this._options.type);
+    }
+    let ds;
+    switch (this._options.type) {
+      case "vector":
+        ds = isStringFull(src) ? {
+          type: "vector",
+          url: src
+        } : (
+          // For null src use an empty geojson datasource as a placeholder
+          {
+            type: "geojson",
+            data: { type: "FeatureCollection", features: [] }
+          }
+        );
+        if (this._options.featureId) {
+          ds.promoteId = this._options.featureId;
+        }
+        return ds;
+      case "raster":
+        ds = isStringFull(src) ? {
+          type: "raster",
+          url: src
+        } : (
+          // For null src use an empty geojson datasource as a placeholder
+          {
+            type: "geojson",
+            data: { type: "FeatureCollection", features: [] }
+          }
+        );
+        return ds;
+      case "geojson":
+        ds = {
+          type: "geojson",
+          data: src || { type: "FeatureCollection", features: [] }
+        };
+        if (this._options.cluster) {
+          ds.cluster = true;
+          ds.clusterMaxZoom = this._options.clusterMaxZoom;
+          ds.clusterMinPoints = this._options.clusterMinPoints;
+          ds.clusterRadius = this._options.clusterRadius;
+        }
+        if (this._options.featureId) {
+          ds.promoteId = this._options.featureId;
+        }
+        return ds;
+      default:
+        throw new FlowCoreError(`${this.formattedName()}: unrecognized type '${this._options.type}'`);
+    }
+  }
+  bindState(state) {
+    this._state = state;
+    if (this._srcExpression) {
+      this._srcExpression?.bindState(state);
+    }
+    Object.values(this._parameters).forEach((expr) => expr.bindState(state));
+    return this;
+  }
+  setSrc(val) {
+    this._options.src = val;
+    this.setSrcExpression(val);
+  }
+  setParameter(name, expression) {
+    if (isNil(expression)) {
+      delete this._parameters[name];
+    } else {
+      const expr = new ReactiveExpression(expression);
+      this._parameters[name] = expr.bindState(this._state);
+    }
+  }
+  setFlowEndpoint(endpoint) {
+    this._options.flowHost = endpoint.host;
+    this._options.flowApiKey = endpoint.apiKey;
+  }
+  formattedName(id) {
+    return `MapDataSource<${id || this._options.id}>`;
+  }
+  setSrcExpression(src) {
+    if (isString(src)) {
+      if (isURL(src))
+        src = `'${src}'`;
+      this._srcExpression = new ReactiveExpression(src);
+      this._srcExpression.bindState(this._state);
+    } else {
+      this._srcExpression = null;
+    }
+  }
+  /**
+   * Convert a src parameter to final URL
+   *
+   * @param src Data source url/dataset/tilesource ID
+   * @param type Data source type
+   * @returns URL
+   */
+  expandSrc(src, type) {
+    const host = this._options.flowHost;
+    let isGeoJSON = false;
+    if (!isURL(src)) {
+      switch (type) {
+        case "vector":
+        case "raster":
+          src = `${host}/tiles/${src}/index.json`;
+          break;
+        case "geojson":
+          src = `${host}/api/v1/datasets/${src}/query`;
+          isGeoJSON = true;
+          break;
+        default:
+          throw new FlowCoreError(`${this.formattedName()}: unrecognized type '${this._options.type}'`);
+      }
+    }
+    const urlObj = new URL(src);
+    const combinedParams = new URLSearchParams(urlObj.searchParams);
+    Object.entries(this._parameters).filter(([_, expr]) => !isNil(expr.value)).forEach(([key, expr]) => combinedParams.append(key, expr.value));
+    if (this._options.flowHost && src.startsWith(this._options.flowHost) && !combinedParams.has("apikey") && this._options.flowApiKey) {
+      combinedParams.append("apikey", this._options.flowApiKey);
+    }
+    if (this._options.limit) {
+      combinedParams.append("limit", this._options.limit.toString(10));
+    }
+    if (isGeoJSON) {
+      combinedParams.append("format", "geojson");
+    }
+    urlObj.search = combinedParams.toString();
+    return urlObj.toString();
+  }
+};
+__publicField(_MapDataSource, "defaultOptions", {
+  type: "vector",
+  cluster: false,
+  clusterRadius: 50,
+  clusterMaxZoom: 20,
+  clusterMinPoints: 2,
+  flowHost: "https://flow.emu-analytics.net"
+});
+let MapDataSource = _MapDataSource;
+
+export { MapDataSource };