@emuanalytics/flow-rdf-core 4.0.3 → 4.0.5

package/dist/lib/map-style/map-layer-style-builder.mjs

@@ -0,0 +1,86 @@
+import { isString, isNumber, isBoolean, isArray } from '../utils/type-checks.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;
+};
+class MapLayerStyleBuilder {
+  constructor() {
+    __publicField(this, "_styles", /* @__PURE__ */ new Map());
+  }
+  static registerStyleBuilder(layerType, builder) {
+    this._styleBuilders.set(layerType, builder);
+  }
+  static createStyleBuilder(layerType) {
+    const builder = this._styleBuilders.get(layerType);
+    if (!builder) {
+      throw new Error(`MapLayerStyleBuilder: Unknown layer type '${layerType}'`);
+    }
+    return new builder();
+  }
+  /**
+   * Whether this layer is displayed.
+   *
+   * @param value - visible value (default `true`)
+   */
+  visibility(value) {
+    this.addStyle("visibility", value);
+    return this;
+  }
+  /**
+   * Create a style specification string.
+   *
+   * Call this method after setting all style properties
+   * on the style builder.
+   *
+   * @returns Layer style specification string
+   */
+  build() {
+    const styles = [];
+    for (const [prop, value] of this._styles.entries()) {
+      styles.push(`${prop}: ${value};`);
+    }
+    return styles.join("\n");
+  }
+  /**
+   * Format and add style property to the style builder.
+   */
+  addStyle(property, value) {
+    this._styles.set(property, this.formatValue(value));
+  }
+  formatValue(value) {
+    if (isStyleExpression(value)) {
+      return value.toString();
+    } else if (isString(value)) {
+      return `'${value.toString()}'`;
+    } else if (isNumber(value)) {
+      return value.toString();
+    } else if (isBoolean(value)) {
+      return (!!value).toString();
+    } else if (isArray(value)) {
+      return `[${value.map((v) => this.formatValue(v)).join(", ")}]`;
+    } else {
+      return value.toString();
+    }
+  }
+}
+__publicField(MapLayerStyleBuilder, "_styleBuilders", /* @__PURE__ */ new Map());
+class StyleExpression {
+  constructor(_expr) {
+    this._expr = _expr;
+    __publicField(this, "__styleExpression", "styleexpression");
+  }
+  toString() {
+    return this._expr;
+  }
+}
+function isStyleExpression(val) {
+  return val && val.__styleExpression;
+}
+function expr(expr2) {
+  return new StyleExpression(expr2);
+}
+
+export { MapLayerStyleBuilder, StyleExpression, expr };

package/dist/lib/map-style/map-layer.mjs

@@ -0,0 +1,223 @@
+import * as maplibreSpec from '@emuanalytics/maplibre-gl-style-spec';
+import { makeObservable, observable, computed, action } from 'mobx';
+import { isDefined, isObjectFull, isNil } from '../utils/type-checks.mjs';
+import { ReactiveExpression } from '../expressions/reactive-expression.mjs';
+import { FlowCoreError } from '../errors/flow-error.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 _MapLayer = class _MapLayer {
+  constructor(options) {
+    __publicField(this, "_options");
+    __publicField(this, "_state", null);
+    __publicField(this, "_filter", null);
+    __publicField(this, "_paintProps", {});
+    __publicField(this, "_layoutProps", {});
+    this._options = {
+      ..._MapLayer._defaultOptions,
+      ...options
+    };
+    this.getPropertyMetadata("visibility", options.type);
+    makeObservable(
+      this,
+      {
+        //observable
+        _paintProps: observable,
+        _layoutProps: observable,
+        _filter: observable,
+        _options: observable,
+        //computed
+        layerSpecification: computed,
+        // actions
+        bindState: action,
+        setMinZoom: action,
+        setMaxZoom: action,
+        setInteractive: action,
+        setAbove: action,
+        setBelow: action,
+        setStyle: action,
+        setStyleProperty: action,
+        setFilter: action
+      },
+      { name: this.formattedName(options.id) }
+    );
+    if (options.filter) {
+      this.setFilter(options.filter);
+    }
+    if (options.style) {
+      this.setStyle(options.style);
+    }
+  }
+  get layerSpecification() {
+    this._options.above;
+    this._options.below;
+    const layer = {
+      id: this._options.id,
+      type: this._options.type,
+      source: this._options.source
+    };
+    if (isDefined(this._options.minZoom)) {
+      layer.minzoom = this._options.minZoom;
+    }
+    if (isDefined(this._options.maxZoom)) {
+      layer.maxzoom = this._options.maxZoom;
+    }
+    if (isDefined(this._options.sourceLayer)) {
+      layer["source-layer"] = this._options.sourceLayer;
+    }
+    if (isDefined(this._filter)) {
+      layer.filter = this._filter.maplibreExpression;
+    }
+    if (isObjectFull(this._paintProps)) {
+      layer.paint = Object.keys(this._paintProps).reduce((accum, key) => {
+        accum[key] = this._paintProps[key].maplibreExpression;
+        return accum;
+      }, {});
+    }
+    if (isObjectFull(this._layoutProps)) {
+      layer.layout = Object.keys(this._layoutProps).reduce((accum, key) => {
+        let expr = this._layoutProps[key].maplibreExpression;
+        if (key === "visibility") {
+          expr = this._layoutProps[key].value ? "visible" : "none";
+        }
+        accum[key] = expr;
+        return accum;
+      }, {});
+    }
+    return layer;
+  }
+  get id() {
+    return this._options.id;
+  }
+  get type() {
+    return this._options.type;
+  }
+  get source() {
+    return this._options.source;
+  }
+  get interactive() {
+    return !!this._options.interactive;
+  }
+  get above() {
+    return this._options.above;
+  }
+  get below() {
+    return this._options.below;
+  }
+  bindState(state) {
+    this._state = state;
+    if (this._filter) {
+      this._filter.bindState(state);
+    }
+    Object.values(this._paintProps).forEach((prop) => prop.bindState(state));
+    Object.values(this._layoutProps).forEach((prop) => prop.bindState(state));
+    return this;
+  }
+  setMinZoom(zoom) {
+    this._options.minZoom = zoom;
+    return this;
+  }
+  setMaxZoom(zoom) {
+    this._options.maxZoom = zoom;
+    return this;
+  }
+  setInteractive(interactive) {
+    this._options.interactive = interactive;
+    return this;
+  }
+  setAbove(layerId) {
+    this._options.above = layerId;
+    return this;
+  }
+  setBelow(layerId) {
+    this._options.below = layerId;
+    return this;
+  }
+  setStyle(styleProgram) {
+    const parsedProgram = ReactiveExpression.parseProgram(styleProgram);
+    const props = Object.keys(parsedProgram);
+    props.forEach((prop) => {
+      const metadata = this.getPropertyMetadata(prop, this._options.type);
+      const layerProps = metadata.type === "paint" ? this._paintProps : this._layoutProps;
+      layerProps[prop] = parsedProgram[prop].bindState(this._state);
+    });
+  }
+  /**
+   * Set an individual style property.
+   *
+   * @param property Property name.
+   * @param expression Property style expression.
+   */
+  setStyleProperty(property, expression) {
+    const metadata = this.getPropertyMetadata(property, this._options.type);
+    const props = metadata.type === "paint" ? this._paintProps : this._layoutProps;
+    if (isNil(expression)) {
+      delete props[property];
+    } else {
+      const expr = new ReactiveExpression(expression).bindState(this._state);
+      if (expr.parseError) {
+        throw expr.parseError;
+      }
+      props[property] = expr;
+    }
+  }
+  setFilter(expression) {
+    this._filter = null;
+    if (isDefined(expression)) {
+      let expr = new ReactiveExpression(expression).bindState(this._state);
+      if (expr.parseError) {
+        throw expr.parseError;
+      }
+      if (!maplibreSpec.expression.isExpressionFilter(expr.maplibreExpression)) {
+        expr = new ReactiveExpression(expr.expression, ["to-boolean", expr.maplibreExpression]);
+      }
+      this._filter = expr;
+    }
+  }
+  formattedName(id) {
+    return `MapLayer<${id || this._options.id}>`;
+  }
+  getPropertyMetadata(property, layerType) {
+    if (!_MapLayer._propertyMetadataIndex) {
+      _MapLayer.initializePropertyMetadataIndex();
+    }
+    const layerMetadata = _MapLayer._propertyMetadataIndex[layerType];
+    if (!layerMetadata) {
+      throw new FlowCoreError(`${this.formattedName()}: unknown layer type '${layerType}'`);
+    }
+    const propertyMetadata = layerMetadata[property];
+    if (!propertyMetadata) {
+      throw new FlowCoreError(`${this.formattedName()}: unknown layer property '${property}'`);
+    }
+    return propertyMetadata;
+  }
+  static initializePropertyMetadataIndex() {
+    const layerTypes = Object.keys(maplibreSpec.latest.layer.type.values);
+    this._propertyMetadataIndex = layerTypes.reduce((acc, layerType) => {
+      acc[layerType] = {};
+      ["layout", "paint"].forEach((propType) => {
+        Object.keys(maplibreSpec.latest[`${propType}_${layerType}`]).forEach((prop) => {
+          acc[layerType][prop] = {
+            property: prop,
+            type: propType,
+            definition: maplibreSpec.latest[`${propType}_${layerType}`][prop]
+          };
+        });
+      });
+      return acc;
+    }, {});
+  }
+};
+__publicField(_MapLayer, "_propertyMetadataIndex");
+__publicField(_MapLayer, "_defaultOptions", {
+  interactive: true,
+  minZoom: 0,
+  maxZoom: 18
+});
+let MapLayer = _MapLayer;
+
+export { MapLayer };

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

@@ -0,0 +1,178 @@
+import { makeObservable, observable, computed, action } from 'mobx';
+import { isNil } from '../utils/type-checks.mjs';
+import { FlowCoreError } from '../errors/flow-error.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 _MapStyle = class _MapStyle {
+  constructor() {
+    __publicField(this, "_state", null);
+    __publicField(this, "_baseStyle");
+    __publicField(this, "_sources", {});
+    __publicField(this, "_layers", {});
+    __publicField(this, "_layerOrder", []);
+    this._baseStyle = _MapStyle._defaultBaseStyle;
+    makeObservable(
+      this,
+      {
+        //observable
+        _sources: observable,
+        _layers: observable,
+        _layerOrder: observable,
+        _baseStyle: observable.ref,
+        //computed
+        styleSpecification: computed,
+        // actions
+        bindState: action,
+        setBaseStyle: action,
+        addSource: action,
+        removeSource: action,
+        addLayer: action,
+        removeLayer: action
+      },
+      { name: this.formattedName }
+    );
+  }
+  get styleSpecification() {
+    const spec = {
+      ...this._baseStyle,
+      sources: { ...this._baseStyle.sources },
+      layers: [...this._baseStyle.layers]
+    };
+    Object.values(this._sources).forEach((source) => {
+      spec.sources[source.id] = source.dataSourceSpecification;
+    });
+    this._layerOrder.forEach((id) => {
+      const layer = this._layers[id];
+      const layerSpec = layer.layerSpecification;
+      const baseLayerIndex = spec.layers.findIndex((l) => l.id === id);
+      if (baseLayerIndex >= 0) {
+        const baseLayer = spec.layers[baseLayerIndex];
+        const mergedBaseLayer = {
+          ...baseLayer,
+          paint: {
+            ...baseLayer.paint,
+            ...layerSpec.paint
+          },
+          layout: {
+            ...baseLayer.layout,
+            ...layerSpec.layout
+          }
+        };
+        spec.layers.splice(baseLayerIndex, 1, mergedBaseLayer);
+      } else {
+        const source = spec.sources[layer.source];
+        if (source.type === "vector" && isNil(layerSpec["source-layer"])) {
+          layerSpec["source-layer"] = "geometry";
+        }
+        const layerIndex = this.layerInsertionPoint(layer, spec);
+        spec.layers.splice(layerIndex, 0, layer.layerSpecification);
+      }
+    });
+    return spec;
+  }
+  get formattedName() {
+    return `MapStyle<${this._baseStyle.id}>`;
+  }
+  bindState(state) {
+    this._state = state;
+    state.transaction(() => {
+      Object.values(this._sources).forEach((source) => source.bindState(state));
+      Object.values(this._layers).forEach((layer) => layer.bindState(state));
+    });
+    return this;
+  }
+  setBaseStyle(style) {
+    this._baseStyle = style ? Object.freeze({ ...style }) : _MapStyle._defaultBaseStyle;
+    return this;
+  }
+  addSource(source) {
+    this._sources[source.id] = source;
+    source.bindState(this._state);
+    return this;
+  }
+  removeSource(id, removeLayers = false) {
+    if (!this._sources[id]) {
+      throw new FlowCoreError(`${this.formattedName}: no source with id '${id}'`);
+    }
+    const linkedLayers = Object.values(this._layers).filter((layer) => layer.source === id).map((layer) => layer.id);
+    if (removeLayers) {
+      linkedLayers.forEach((id2) => this.removeLayer(id2));
+    } else if (linkedLayers.length) {
+      throw new FlowCoreError(
+        `${this.formattedName}: cannot remove source with id '${id}' when in use by layers ${linkedLayers.join(", ")}`
+      );
+    }
+    delete this._sources[id];
+    return this;
+  }
+  getSource(id) {
+    const source = this._sources[id];
+    if (!source) {
+      throw new FlowCoreError(`${this.formattedName}: no source with id '${id}'`);
+    }
+    return source;
+  }
+  getSources(filter) {
+    return Object.values(this._sources).filter((source) => filter ? filter(source) : true);
+  }
+  addLayer(layer) {
+    if (!this._sources[layer.source] && !this._baseStyle.sources[layer.source]) {
+      throw new FlowCoreError(`${this.formattedName}: no source with id '${layer.source}'`);
+    }
+    this._layers[layer.id] = layer;
+    this._layerOrder.push(layer.id);
+    layer.bindState(this._state);
+    return this;
+  }
+  removeLayer(id) {
+    if (!this._layers[id]) {
+      throw new FlowCoreError(`${this.formattedName}: no layer with id '${id}'`);
+    }
+    delete this._layers[id];
+    const index = this._layerOrder.indexOf(id);
+    this._layerOrder.splice(index, 1);
+    return this;
+  }
+  getLayer(id) {
+    const layer = this._layers[id];
+    if (!layer) {
+      throw new FlowCoreError(`${this.formattedName}: no layer with id '${id}'`);
+    }
+    return layer;
+  }
+  getLayers(filter) {
+    return this._layerOrder.map((layerId) => this._layers[layerId]).filter((layer) => filter ? filter(layer) : true);
+  }
+  layerInsertionPoint(layer, spec) {
+    let insertionIndex = -1;
+    if (layer.above) {
+      insertionIndex = spec.layers.findIndex((l) => l.id === layer.above);
+      if (insertionIndex >= 0)
+        insertionIndex++;
+    } else if (layer.below) {
+      insertionIndex = spec.layers.findIndex((l) => l.id === layer.below);
+    } else {
+      const below = spec.metadata?.insertionPoints?.[layer.type];
+      insertionIndex = spec.layers.findIndex((l) => l.id === below);
+    }
+    if (insertionIndex === -1) {
+      insertionIndex = spec.layers.length;
+    }
+    return insertionIndex;
+  }
+};
+__publicField(_MapStyle, "_defaultBaseStyle", Object.freeze({
+  version: 8,
+  id: "default",
+  name: "Default base style",
+  sources: {},
+  layers: []
+}));
+let MapStyle = _MapStyle;
+
+export { MapStyle };

package/dist/lib/queries/async-committer.mjs

@@ -0,0 +1,30 @@
+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;
+};
+class AsyncCommitter {
+  constructor() {
+    __publicField(this, "_requestId", 0);
+    __publicField(this, "_commitId", 0);
+  }
+  async resolve(promise) {
+    this._requestId += 1;
+    const currentRequestId = this._requestId;
+    const value = await promise;
+    if (currentRequestId <= this._commitId) {
+      return { succeeded: false };
+    }
+    this._commitId = currentRequestId;
+    return { succeeded: true, value };
+  }
+  async run(asyncFunction) {
+    return this.resolve(asyncFunction());
+  }
+  abandon() {
+    this._commitId = this._requestId;
+  }
+}
+
+export { AsyncCommitter };

package/dist/lib/queries/query.mjs

@@ -0,0 +1,172 @@
+import Debug from 'debug';
+import { makeObservable, observable, onBecomeObserved, onBecomeUnobserved, reaction, runInAction } from 'mobx';
+import { randomId } from '../utils/random-id.mjs';
+import { AsyncCommitter } from './async-committer.mjs';
+import { getGlobalState } from '../context/global-state.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 debug = Debug("flow:query");
+const DEFAULT_DELAY = 100;
+const _Query = class _Query {
+  constructor(queryFn, transformFn, options) {
+    this.queryFn = queryFn;
+    __publicField(this, "_options");
+    __publicField(this, "_committer", new AsyncCommitter());
+    __publicField(this, "_disposer", null);
+    __publicField(this, "_transformFn", (results) => results);
+    __publicField(this, "results", null);
+    __publicField(this, "busy", false);
+    __publicField(this, "error", null);
+    this._options = {
+      ..._Query._defaultOptions,
+      ...options
+    };
+    this._options.id = this._options.id ?? randomId("query");
+    makeObservable(
+      this,
+      {
+        results: observable.ref,
+        busy: observable,
+        error: observable.ref
+      },
+      {
+        name: "flowQuery"
+      }
+    );
+    onBecomeObserved(this, "results", this.wake.bind(this));
+    onBecomeUnobserved(this, "results", this.sleep.bind(this));
+    if (transformFn) {
+      this._transformFn = transformFn;
+    }
+    getGlobalState().globalContextRegistry.getContext(this._options?.contextId).then((context) => {
+      context.queries.registerQuery(this);
+    });
+  }
+  static setDefaultOptions(options) {
+    this._defaultOptions = { ...this._defaultOptions, ...options };
+  }
+  get formattedName() {
+    return `Query<${this._options.id}>`;
+  }
+  get id() {
+    return this._options.id;
+  }
+  destroy() {
+    getGlobalState().globalContextRegistry.getContext(this._options?.contextId).then((context) => {
+      context.queries.unregisterQuery(this);
+    });
+  }
+  async runImmediately() {
+    const context = await getGlobalState().globalContextRegistry.getContext(this._options.contextId);
+    const queryDefinition = this.queryFn.call(context.state, context.state);
+    await this.runQuery(queryDefinition);
+    if (this.error) {
+      throw this.error;
+    }
+    return this.results;
+  }
+  async wake() {
+    this.sleep();
+    const context = await getGlobalState().globalContextRegistry.getContext(this._options.contextId);
+    this._disposer = reaction(
+      (r) => {
+        return this.queryFn.call(context.state, context.state);
+      },
+      (queryDefinition, prev, r) => {
+        this.runQuery(queryDefinition);
+      },
+      { name: this.formattedName, fireImmediately: this._options.fireImmediately, delay: this._options.delay }
+    );
+  }
+  sleep() {
+    if (this._disposer) {
+      runInAction(() => {
+        this.results = null;
+        this.error = null;
+        this.busy = false;
+        this._committer.abandon();
+      });
+      const disposer = this._disposer;
+      this._disposer = null;
+      disposer();
+    }
+  }
+  async runQuery(queryDefinition) {
+    debug(`${this.formattedName}: running query`, queryDefinition);
+    const context = await getGlobalState().globalContextRegistry.getContext(this._options.contextId);
+    try {
+      if (queryDefinition === null) {
+        runInAction(() => {
+          this.results = null;
+          this.error = null;
+          this.busy = false;
+        });
+      } else {
+        runInAction(() => {
+          this.busy = true;
+          this.error = null;
+        });
+        const response = await this._committer.run(() => {
+          return context.flowClient.datasets.query(queryDefinition);
+        });
+        if (response.succeeded) {
+          runInAction(() => {
+            this.results = this._transformFn(response.value);
+            this.busy = false;
+          });
+        } else {
+        }
+      }
+    } catch (e) {
+      console.error(`${this.formattedName}: ${e.message}`);
+      runInAction(() => {
+        this.results = null;
+        this.error = e;
+        this.busy = false;
+      });
+    }
+  }
+};
+__publicField(_Query, "_defaultOptions", {
+  fireImmediately: true,
+  delay: DEFAULT_DELAY
+});
+let Query = _Query;
+function query(queryFn, transformFnOrOptions, options) {
+  if (typeof transformFnOrOptions === "object") {
+    options = transformFnOrOptions;
+    transformFnOrOptions = void 0;
+  }
+  return new Query(queryFn, transformFnOrOptions, options);
+}
+function queryMany(queryFn, transformFnOrOptions, options) {
+  if (typeof transformFnOrOptions === "object") {
+    options = transformFnOrOptions;
+    transformFnOrOptions = void 0;
+  }
+  return query(queryFn, transformFnOrOptions, options);
+}
+function queryOne(queryFn, transformFnOrOptions, options) {
+  if (typeof transformFnOrOptions === "object") {
+    options = transformFnOrOptions;
+    transformFnOrOptions = void 0;
+  }
+  const oneTransform = (results) => {
+    let oneResult = null;
+    if (results?.length) {
+      oneResult = results[0];
+    }
+    if (transformFnOrOptions && typeof transformFnOrOptions === "function") {
+      oneResult = transformFnOrOptions(oneResult);
+    }
+    return oneResult;
+  };
+  return query(queryFn, oneTransform, options);
+}
+
+export { Query, query, queryMany, queryOne };