@emuanalytics/flow-rdf-core 4.0.3 → 4.0.5

package/dist/shared/flow-rdf-core.65045caf.mjs

@@ -1,1360 +0,0 @@
-import * as mobx from 'mobx';
-import { makeObservable, observable, computed, action, onBecomeObserved, onBecomeUnobserved, runInAction } from 'mobx';
-import { f as isString, j as isArray, b as isNil, d as isDefined, r as isIn, g as isStringFull, z as isURL, n as isObjectFull, c as capitalize } from './flow-rdf-core.25e5f6d7.mjs';
-import * as maplibreSpec from '@emuanalytics/maplibre-gl-style-spec';
-import { toStream } from 'mobx-utils';
-import P from 'parsimmon';
-import colorbrewer from 'colorbrewer';
-import Debug from 'debug';
-
-class FlowError extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = this.constructor.name;
-    this.cause = cause;
-  }
-}
-
-class FlowExpressionError extends FlowError {
-  constructor(expression, reason, errors) {
-    super(`Failed to evaluate expression:
-${expression}
-------
-${errors.join(", ")}`);
-    this.reason = reason;
-    this.errors = errors;
-  }
-}
-
-function PREFIX(operatorsParser, nextParser) {
-  const parser = P.lazy(() => {
-    return P.seq(operatorsParser, parser).or(nextParser);
-  });
-  return parser;
-}
-function BINARY_RIGHT(operatorsParser, nextParser) {
-  const parser = P.lazy(() => nextParser.chain((next) => P.seq(operatorsParser, P.of(next), parser).or(P.of(next))));
-  return parser;
-}
-function TERNARY_RIGHT(operatorsParser, nextParser) {
-  const parser = P.lazy(
-    () => nextParser.chain(
-      (next) => P.seqMap(
-        operatorsParser,
-        P.of(next),
-        parser,
-        P.string(":").trim(P.optWhitespace),
-        parser,
-        (op, cond, val1, _colon, val2) => [op, ["to-boolean", cond], val1, val2]
-      ).or(P.of(next))
-    )
-  );
-  return parser;
-}
-function BINARY_LEFT(operatorsParser, nextParser) {
-  return P.seqMap(nextParser, P.seq(operatorsParser, nextParser).many(), (first, rest) => {
-    return rest.reduce((acc, ch) => {
-      const [op, another] = ch;
-      return [op, acc, another];
-    }, first);
-  });
-}
-
-var __defProp$7 = Object.defineProperty;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$7 = (obj, key, value) => {
-  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class ExpressionParser {
-  constructor() {
-    __publicField$7(this, "language");
-    this.language = this.createLanguage();
-  }
-  /**
-   * Parse an expression
-   *
-   * @param expr Expression to parse
-   */
-  parseExpression(expr) {
-    return this.language.Expr.parse(expr);
-  }
-  /**
-   * Parse a complete assignment program of the form:
-   * a: expr1;
-   * b: expr2;
-   *
-   * @param program Program to parse
-   */
-  parseProgram(program) {
-    return this.language.ProgramOrEmpty.parse(program);
-  }
-  createLanguage() {
-    const operatorTable = [
-      { type: PREFIX, ops: this.operators({ "-": "-", "!": "!" }) },
-      { type: BINARY_RIGHT, ops: this.operators({ "^": "**" }) },
-      { type: BINARY_LEFT, ops: this.operators({ "*": "*", "/": "/", "%": "%" }) },
-      { type: BINARY_LEFT, ops: this.operators({ "+": "+", "-": "-" }) },
-      { type: BINARY_LEFT, ops: this.operators({ ">=": ">=", "<=": "<=" }) },
-      { type: BINARY_LEFT, ops: this.operators({ "<": "<", ">": ">" }) },
-      {
-        type: BINARY_LEFT,
-        ops: this.operators({ regexi: "~*", equali: "=*", "==": "==", "!=": "!=", "~": "~" })
-      },
-      { type: BINARY_LEFT, ops: this.operators({ all: "&&" }) },
-      { type: BINARY_LEFT, ops: this.operators({ any: "||" }) },
-      { type: TERNARY_RIGHT, ops: this.operators({ case: "?" }) }
-    ];
-    return P.createLanguage({
-      Whitespace: () => P.regexp(/[ \n]*/).desc("whitespace"),
-      NotNewline: () => P.regexp(/[^\n]*/).desc("non-newline"),
-      LineComment: (r) => r.NotNewline.wrap(P.string("//"), P.alt(P.string("\n"), P.eof)),
-      BlockComment: () => P.regexp(/\/\*[\s\S]*?\*\//),
-      Comment: (r) => P.alt(r.LineComment, r.BlockComment).desc("comment"),
-      End: () => P.alt(P.string(";"), P.eof),
-      _: (r) => r.Comment.sepBy(r.Whitespace).trim(r.Whitespace),
-      Integer: () => {
-        return P.regexp(/-?[0-9]+/).map(Number);
-      },
-      Decimal: () => {
-        return P.regexp(/-?[0-9]+\.[0-9]+/).map(Number);
-      },
-      Number: (r) => {
-        return P.alt(r.Decimal, r.Integer).desc("number");
-      },
-      Boolean: () => {
-        return P.alt(P.string("true"), P.string("false")).map((val) => val === "true").desc("boolean");
-      },
-      Null: () => {
-        return P.string("null").result(null).desc("null");
-      },
-      DoubleQuoteString: () => {
-        return P.regexp(/"((?:\\.|.)*?)"/, 1).desc("string");
-      },
-      SingleQuoteString: () => {
-        return P.regexp(/'((?:\\.|.)*?)'/, 1).desc("string");
-      },
-      UnquotedString: () => {
-        return P.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/).desc("string");
-      },
-      HexColor: () => {
-        return P.regexp(/#(?:[0-9a-f]{3}){1,2}/i).desc("hex color");
-      },
-      String: (r) => {
-        return P.alt(r.SingleQuoteString, r.DoubleQuoteString, r.HexColor, r.UnquotedString).map(
-          (s) => s.replace(/\\n/gm, "\n")
-        );
-      },
-      Symbol: () => {
-        return P.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/).desc("symbol");
-      },
-      PartialSymbol: () => {
-        return P.regexp(/[a-zA-Z0-9_-]+/).desc("symbol");
-      },
-      Feature: (r) => {
-        return P.seqMap(
-          P.string("@"),
-          r.PartialSymbol.sepBy(P.string(".")),
-          (_feat, symbols) => ["get"].concat(symbols)
-        );
-      },
-      FeatureState: (r) => {
-        return P.seqMap(
-          P.string("@@"),
-          r.PartialSymbol.sepBy(P.string(".")),
-          (_feat, symbols) => this.expandFeatureState(symbols)
-        );
-      },
-      Array: (r) => P.string("[").trim(r._).then(r.Value.trim(r._).sepBy(P.string(","))).skip(P.string("]")),
-      State: (r) => {
-        return P.seqMap(
-          P.string("$"),
-          r.PartialSymbol.sepBy(P.string(".")),
-          (_state, symbols) => ["state"].concat(symbols)
-        );
-      },
-      Paren: (r) => {
-        return P.seqMap(P.string("("), r.Expr.trim(r._), P.string(")"), (_lb, expr, _rb) => expr);
-      },
-      Func: (r) => {
-        return P.seqMap(
-          r.Symbol.trim(r._),
-          P.string("("),
-          r.Expr.trim(r._).sepBy(P.string(",")),
-          P.string(")"),
-          (func, _lb, args, _rb) => [func, ...args]
-        );
-      },
-      Value: (r) => {
-        return P.alt(
-          r.Paren,
-          r.Array,
-          r.Func,
-          r.Boolean,
-          r.Null,
-          r.Number,
-          r.String,
-          r.FeatureState,
-          r.Feature,
-          r.State
-        );
-      },
-      Expr: (r) => {
-        return this.tableParser(operatorTable, r.Value);
-      },
-      PropertyName: () => {
-        return P.regexp(/[a-zA-Z_-][a-zA-Z0-9_-]*/).desc("symbol");
-      },
-      Assignment: (r) => {
-        return P.seqMap(
-          r.PropertyName,
-          P.string(":").trim(r._),
-          r.Expr.trim(r._).node("expr"),
-          r.End,
-          (key, _colon, node) => [key, { expr: node.value, start: node.start, end: node.end }]
-        );
-      },
-      Program: (r) => {
-        return r.Assignment.trim(r._).many().map((statements) => {
-          return statements.filter((s) => s !== "").reduce((acc, s) => {
-            acc[s[0]] = s[1];
-            return acc;
-          }, {});
-        });
-      },
-      EmptyProgram: (r) => {
-        return P.seqMap(r._, P.eof, () => null);
-      },
-      ProgramOrEmpty: (r) => {
-        return P.alt(r.EmptyProgram, r.Program);
-      }
-    });
-  }
-  /**
-   * Helper function to create a parser that parsers a set of operators at the same precedence level
-   *
-   * @param ops Operator table
-   */
-  operators(ops) {
-    const keys = Object.keys(ops);
-    const ps = keys.map((k) => P.string(ops[k]).trim(P.optWhitespace).result(k));
-    return P.alt.apply(null, ps);
-  }
-  /**
-   * Helper function to create a table-driver operator parser
-   *
-   */
-  tableParser(operatorTable, valueParser) {
-    return operatorTable.reduce((acc, level) => level.type(level.ops, acc), valueParser);
-  }
-  expandFeatureState(symbols) {
-    let expandedFeatureState = ["feature-state", symbols.shift()];
-    symbols.forEach((s) => expandedFeatureState = ["get", s, expandedFeatureState]);
-    return expandedFeatureState;
-  }
-}
-
-const palettes = {};
-function registerColorBrewerPalettes() {
-  Object.keys(colorbrewer).filter((key) => key !== "schemeGroups").forEach(
-    (key) => palettes[key.toLowerCase()] = {
-      id: key,
-      colors: colorbrewer[key][5]
-    }
-  );
-}
-function fromPalette(expr, parentExpression) {
-  const paletteIdOrArray = expr[1];
-  const property = expr[2];
-  let colorStops = expr.slice(3);
-  let palette;
-  if (isString(paletteIdOrArray)) {
-    palette = palettes[paletteIdOrArray.toLowerCase()]?.colors || palettes["Greys"].colors;
-  } else if (isArray(paletteIdOrArray) && paletteIdOrArray[0] === "literal") {
-    palette = paletteIdOrArray[1];
-  } else {
-    throw new FlowExpressionError(parentExpression.expression, "evaluationError", [
-      "from-palette requires palette id as string or custom palette array"
-    ]);
-  }
-  const numPaletteEntries = palette.length;
-  let reversePalette = false;
-  if (numPaletteEntries < 5) {
-    throw new FlowExpressionError(parentExpression.expression, "evaluationError", [
-      "custom palette requires at least 5 color entries"
-    ]);
-  }
-  switch (colorStops.length) {
-    case 2:
-      break;
-    case 3:
-      reversePalette = !!colorStops[2];
-      colorStops = colorStops.slice(0, 2);
-      break;
-    case numPaletteEntries:
-      break;
-    case numPaletteEntries + 1:
-      reversePalette = !!colorStops[numPaletteEntries];
-      colorStops = colorStops.slice(0, numPaletteEntries);
-      break;
-    default:
-      throw new FlowExpressionError(parentExpression.expression, "evaluationError", [
-        "incorrect color stop arguments"
-      ]);
-  }
-  if (colorStops.length === 2) {
-    const min = colorStops[0];
-    const max = colorStops[1];
-    colorStops = [];
-    const step = (max - min) / (numPaletteEntries - 1);
-    for (let i = 0; i < numPaletteEntries; i++) {
-      colorStops.push(min + i * step);
-    }
-  }
-  expr = ["interpolate-lab", ["linear"], property];
-  for (let i = 0; i < colorStops.length; i++) {
-    expr.push(colorStops[i]);
-    expr.push(reversePalette ? palette[colorStops.length - i - 1] : palette[i]);
-  }
-  return expr;
-}
-const customFromPaletteFn = {
-  name: "from-palette",
-  initialize: registerColorBrewerPalettes,
-  fn: fromPalette
-};
-
-function regexFunction(operator, caseSensitive = true) {
-  return (expr, _) => {
-    expr[0] = operator;
-    expr.push(["collator", { "case-sensitive": caseSensitive }]);
-    return expr;
-  };
-}
-const equal = {
-  name: "equal",
-  fn: regexFunction("==", true)
-};
-const equali = {
-  name: "iequal",
-  fn: regexFunction("==", false)
-};
-const regex = {
-  name: "regex",
-  fn: regexFunction("~", true)
-};
-const regexi = {
-  name: "regexi",
-  fn: regexFunction("~", false)
-};
-
-function stateCustomFunction(expr, parentExpression) {
-  if (!parentExpression.store) {
-    console.warn(
-      `The reactive expression '${parentExpression.expression}' references state properties but is not bound to a state store. The expression cannot be evaluated - returning null.`
-    );
-    return null;
-  }
-  const path = expr.slice(1).join(".");
-  const val = parentExpression.store.get(path);
-  if (isNil(val)) {
-    return null;
-  } else if (typeof val === "object") {
-    return ["literal", val];
-  } else {
-    return val;
-  }
-}
-const customStateFn = {
-  name: "state",
-  fn: stateCustomFunction
-};
-
-var __defProp$6 = Object.defineProperty;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => {
-  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _ReactiveExpression = class _ReactiveExpression {
-  constructor(expression, parsedExpression) {
-    __publicField$6(this, "_expression", "");
-    __publicField$6(this, "parsedResult");
-    __publicField$6(this, "_store", null);
-    makeObservable(
-      this,
-      {
-        _store: observable.ref,
-        maplibreExpression: computed,
-        value: computed,
-        bindState: action
-      },
-      { name: this.formatName(expression) }
-    );
-    this._expression = expression;
-    if (isDefined(parsedExpression)) {
-      this.parsedResult = {
-        status: true,
-        value: parsedExpression
-      };
-    } else {
-      this.parsedResult = _ReactiveExpression.parser.parseExpression(expression);
-    }
-  }
-  static hasCustomFunction(fn) {
-    return !!this.customFunctions[fn];
-  }
-  static registerCustomFunction(fn) {
-    if (fn.initialize)
-      fn.initialize();
-    this.customFunctions[fn.name] = fn;
-  }
-  static parseProgram(program) {
-    const parsedProgram = this.parser.parseProgram(program);
-    if (isString(program) && program.length === 0) {
-      return {};
-    }
-    if (parsedProgram.status) {
-      const keys = Object.keys(parsedProgram.value);
-      const expressions = keys.reduce((accum, key) => {
-        const expr = parsedProgram.value[key];
-        const expressionString = program.slice(expr.start.offset, expr.end.offset);
-        accum[key] = new _ReactiveExpression(expressionString, expr.expr);
-        return accum;
-      }, {});
-      return expressions;
-    } else {
-      throw new FlowExpressionError(program, "parseError", [
-        `expected ${parsedProgram.expected.join(" ")} at line ${parsedProgram.index.line}, column ${parsedProgram.index.column}]`
-      ]);
-    }
-  }
-  // Computed
-  get maplibreExpression() {
-    if (this.isParseError(this.parsedResult)) {
-      throw this.parseError;
-    }
-    return this.expandCustomFunctions(this.parsedResult.value);
-  }
-  // Computed
-  get value() {
-    return this.evaluateExpression();
-  }
-  get parseError() {
-    if (this.isParseError(this.parsedResult)) {
-      return new FlowExpressionError(this._expression, "parseError", [
-        `index: ${this.parsedResult.index.offset}`,
-        `expected: ${this.parsedResult.expected.join(" ")}`
-      ]);
-    }
-    return null;
-  }
-  get expression() {
-    return this._expression;
-  }
-  get store() {
-    return this._store;
-  }
-  bindState(store) {
-    this._store = store;
-    return this;
-  }
-  toStream(fireImmediately = true) {
-    return toStream(() => this.value, fireImmediately);
-  }
-  evaluateExpression() {
-    const { result, value } = maplibreSpec.expression.createExpression(this.maplibreExpression);
-    if (result === "success") {
-      return value.evaluate({ zoom: 0 });
-    }
-    throw new FlowExpressionError(
-      this.expression,
-      "evaluationError",
-      value.map((value2) => value2.message)
-    );
-  }
-  expandCustomFunctions(expr) {
-    if (this.isFunctionExpression(expr)) {
-      const func = expr[0];
-      const args = expr.slice(1).map((arg) => this.expandCustomFunctions(arg));
-      expr = [func, ...args];
-      return _ReactiveExpression.hasCustomFunction(func) ? _ReactiveExpression.customFunctions[func].fn(expr, this) : expr;
-    }
-    return expr;
-  }
-  isParseError(val) {
-    return !val.status;
-  }
-  isFunctionExpression(expr) {
-    return Array.isArray(expr);
-  }
-  formatName(expr) {
-    return `FlowCoreExpression<${expr}>}`;
-  }
-};
-__publicField$6(_ReactiveExpression, "parser", new ExpressionParser());
-__publicField$6(_ReactiveExpression, "customFunctions", {});
-let ReactiveExpression = _ReactiveExpression;
-ReactiveExpression.registerCustomFunction(customStateFn);
-ReactiveExpression.registerCustomFunction(customFromPaletteFn);
-ReactiveExpression.registerCustomFunction(regex);
-ReactiveExpression.registerCustomFunction(regexi);
-ReactiveExpression.registerCustomFunction(equal);
-ReactiveExpression.registerCustomFunction(equali);
-
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => {
-  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _MapDataSource = class _MapDataSource {
-  constructor(options) {
-    __publicField$5(this, "_options");
-    __publicField$5(this, "_srcExpression", null);
-    __publicField$5(this, "_parameters", {});
-    __publicField$5(this, "_state", null);
-    this._options = {
-      ..._MapDataSource.defaultOptions,
-      ...options
-    };
-    if (!isIn(options.type, ["vector", "geojson", "raster"])) {
-      throw new FlowError(`${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 FlowError(`${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 FlowError(`${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$5(_MapDataSource, "defaultOptions", {
-  type: "vector",
-  cluster: false,
-  clusterRadius: 50,
-  clusterMaxZoom: 20,
-  clusterMinPoints: 2,
-  flowHost: "https://flow.emu-analytics.net"
-});
-let MapDataSource = _MapDataSource;
-
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _MapLayer = class _MapLayer {
-  constructor(options) {
-    __publicField$4(this, "_options");
-    __publicField$4(this, "_state", null);
-    __publicField$4(this, "_filter", null);
-    __publicField$4(this, "_paintProps", {});
-    __publicField$4(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 FlowError(`${this.formattedName()}: unknown layer type '${layerType}'`);
-    }
-    const propertyMetadata = layerMetadata[property];
-    if (!propertyMetadata) {
-      throw new FlowError(`${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$4(_MapLayer, "_propertyMetadataIndex");
-__publicField$4(_MapLayer, "_defaultOptions", {
-  interactive: true,
-  minZoom: 0,
-  maxZoom: 18
-});
-let MapLayer = _MapLayer;
-
-class FlowMapError extends FlowError {
-  constructor(message, originalError) {
-    super(message, originalError);
-  }
-}
-
-function assert(condition, message) {
-  if (!condition) {
-    throw new FlowError(message ?? "Assertion failed");
-  }
-}
-function die(message) {
-  throw new FlowError(message);
-}
-
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class KeyboardShortcutManager {
-  constructor() {
-    __publicField$3(this, "listeners");
-    /**
-     * Handles key events of the root handler and passes them down to listeners.
-     * @param event
-     */
-    __publicField$3(this, "handleKeyboardEvent", (event) => {
-      if (this.isInputEvent(event))
-        return;
-      const key = this.keyDefinitionFromEvent(event);
-      for (const listener of this.listeners) {
-        const handler = listener.bindings[key];
-        if (handler) {
-          const propagate = handler(event);
-          if (propagate === true) {
-            continue;
-          } else {
-            event.stopPropagation();
-            return;
-          }
-        }
-      }
-    });
-    this.listeners = [];
-    document.addEventListener("keydown", this.handleKeyboardEvent);
-  }
-  /**
-   * Adds listener to keyboard events.
-   * @param bindings Object containing key/value pairs of keyCode/eventHandler function. Can add multiple comma separated `,` keyCodes for the same handler. Can optionally return `false` to stop propagation of other handlers.
-   * @param priority Can optionally set the priority of event handler, higher value means higher priority. Defaults to 0.
-   * @returns Function that can be used to unbind the listener.
-   */
-  addListener(bindings, priority) {
-    bindings = this.splitEventBindings(bindings);
-    const listener = this.addToListeners({ bindings, priority: priority ?? 0 });
-    const removeListener = () => {
-      this.removeFromListeners(listener);
-    };
-    return removeListener;
-  }
-  /**
-   * Splits multiple keyCode events and creates a new bindings map.
-   * @param bindings
-   */
-  splitEventBindings(bindings) {
-    const splitBindings = {};
-    for (const event in bindings) {
-      event.split(",").forEach((splitEvent) => {
-        splitBindings[this.normalizeKeyDefinition(splitEvent)] = bindings[event];
-      });
-    }
-    return splitBindings;
-  }
-  /**
-   * Checks is the event comes from an input type.
-   * @param event
-   */
-  isInputEvent(event) {
-    if (event.target instanceof Node) {
-      switch (event.target.nodeName) {
-        case "INPUT":
-        case "SELECT":
-        case "TEXTAREA":
-          return true;
-        default:
-          return false;
-      }
-    }
-    return false;
-  }
-  /**
-   * Adds listener into internal array of listeners and sorts in `descending` order.
-   * @param listener
-   */
-  addToListeners(listener) {
-    this.listeners.push(listener);
-    this.listeners.sort((a, b) => b.priority - a.priority);
-    return listener;
-  }
-  /**
-   * Removes listener from internal array of listeners.
-   * @param listenerToRemove
-   */
-  removeFromListeners(listenerToRemove) {
-    this.listeners = this.listeners.filter((listener) => listener !== listenerToRemove);
-  }
-  normalizeKeyDefinition(keyDef) {
-    const parts = keyDef.split("+");
-    const ev = {
-      ctrlKey: parts.includes("Ctrl"),
-      shiftKey: parts.includes("Shift"),
-      altKey: parts.includes("Alt"),
-      metaKey: parts.includes("Meta"),
-      code: parts[parts.length - 1]
-    };
-    return this.keyDefinitionFromEvent(ev);
-  }
-  keyDefinitionFromEvent(ev) {
-    let keyDef = "";
-    if (ev.ctrlKey)
-      keyDef += "Ctrl+";
-    if (ev.shiftKey)
-      keyDef += "Shift+";
-    if (ev.altKey)
-      keyDef += "Alt+";
-    if (ev.metaKey)
-      keyDef += "Meta+";
-    keyDef += ev.code;
-    return keyDef;
-  }
-}
-
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const debug = Debug("flow:map-plugin-manager");
-class PluginManager {
-  constructor(map) {
-    __publicField$2(this, "_map");
-    __publicField$2(this, "_keyboardShortcutManager", new KeyboardShortcutManager());
-    __publicField$2(this, "_plugins", /* @__PURE__ */ new Map());
-    __publicField$2(this, "_initialized", false);
-    __publicField$2(this, "_exclusivePlugins", /* @__PURE__ */ new Set());
-    this._map = map;
-    this.map.initialized.then(() => {
-      this._initialized = true;
-      for (const plugin of this._plugins.values()) {
-        if (plugin.initialize) {
-          plugin.initialize();
-        }
-      }
-    });
-  }
-  get map() {
-    return this._map;
-  }
-  usePlugin(plugin, options) {
-    if (this._plugins.has(plugin)) {
-      const oldInstance = this._plugins.get(plugin);
-      if (oldInstance.destroy) {
-        oldInstance.destroy();
-      }
-    }
-    const pluginInstance = new plugin(this, options);
-    this._plugins.set(plugin, pluginInstance);
-    debug(`FlowMap<${this.map.id}>: Using plugin '${pluginInstance.name}'`);
-    if (this._initialized && pluginInstance.initialize)
-      pluginInstance.initialize();
-    return pluginInstance;
-  }
-  getPlugin(pluginOrName) {
-    let name;
-    let pluginInstance;
-    if (isString(pluginOrName)) {
-      pluginInstance = Array.from(this._plugins.values()).find((p) => p.name === pluginOrName);
-      name = pluginOrName;
-    } else {
-      pluginInstance = this._plugins.get(pluginOrName);
-      name = pluginOrName.name;
-    }
-    if (!pluginInstance) {
-      throw new FlowError(`<${name}>: plugin not registered`);
-    }
-    return pluginInstance;
-  }
-  removePlugin(pluginOrName) {
-    let pluginConstructor;
-    let pluginInstance;
-    if (isString(pluginOrName)) {
-      const pair = Array.from(this._plugins.entries()).find(([_, p]) => p.name === pluginOrName);
-      pluginConstructor = pair && pair[0];
-      pluginInstance = pair && pair[1];
-    } else {
-      pluginConstructor = pluginOrName;
-      pluginInstance = this._plugins.get(pluginOrName);
-    }
-    if (pluginInstance && pluginInstance.destroy) {
-      pluginInstance.destroy();
-    }
-    if (pluginConstructor)
-      this._plugins.delete(pluginConstructor);
-    return this;
-  }
-  removeAllPlugins() {
-    this._plugins.forEach((plugin) => {
-      if (plugin.destroy)
-        plugin.destroy();
-    });
-    this._plugins.clear();
-    return this;
-  }
-  setExclusivePlugin(plugin) {
-    this._exclusivePlugins.add(plugin);
-    this.forwardSetExclusivePlugin();
-    return this;
-  }
-  removeExclusivePlugin(plugin) {
-    this._exclusivePlugins.delete(plugin);
-    this.forwardSetExclusivePlugin();
-    return this;
-  }
-  addKeyboardShortcuts(keyboardShortcuts, priority = 0) {
-    return this._keyboardShortcutManager.addListener(keyboardShortcuts, priority);
-  }
-  forwardEvent(eventName, ...args) {
-    const handlerName = `handle${capitalize(eventName)}`;
-    this._plugins.forEach((plugin) => {
-      if (this._exclusivePlugins.size && !this._exclusivePlugins.has(plugin))
-        return;
-      const handler = plugin[handlerName];
-      if (handler) {
-        handler.apply(plugin, args);
-      }
-    });
-  }
-  forwardStyleChangeEvent(event) {
-    this._plugins.forEach((plugin) => {
-      if (this._exclusivePlugins.size && !this._exclusivePlugins.has(plugin))
-        return;
-      if (plugin.handleBeforeStyleChanged) {
-        const result = plugin.handleBeforeStyleChanged(event);
-        if (result) {
-          event.newStyle = result;
-        }
-      }
-    });
-    return event.newStyle;
-  }
-  forwardSetExclusivePlugin() {
-    this._plugins.forEach((plugin) => {
-      if (plugin.handleSetExclusivePlugin) {
-        plugin.handleSetExclusivePlugin(Array.from(this._exclusivePlugins));
-      }
-    });
-  }
-}
-
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class MapEvent {
-  constructor(type, map, originalEvent) {
-    __publicField$1(this, "type");
-    __publicField$1(this, "map");
-    __publicField$1(this, "originalEvent");
-    this.type = type;
-    this.map = map;
-    this.originalEvent = originalEvent;
-  }
-  static fromMaplibreEvent(type, map, maplibreEvent) {
-    return new MapEvent(type, map, maplibreEvent.originalEvent);
-  }
-}
-class MapMouseEvent extends MapEvent {
-  constructor(type, map, point, lngLat, features, originalEvent) {
-    super(type, map, originalEvent);
-    /**
-     * The pixel coordinates of the mouse cursor, relative to the map and measured from the top left corner.
-     */
-    __publicField$1(this, "point");
-    /**
-     * The geographic location on the map of the mouse cursor.
-     */
-    __publicField$1(this, "lngLat");
-    __publicField$1(this, "features");
-    this.point = point;
-    this.lngLat = lngLat;
-    this.features = features;
-  }
-  static fromMaplibreMouseEvent(type, maplibreMouseEvent, map, features) {
-    return new MapMouseEvent(
-      type,
-      map,
-      [maplibreMouseEvent.point.x, maplibreMouseEvent.point.y],
-      [maplibreMouseEvent.lngLat.lng, maplibreMouseEvent.lngLat.lat],
-      features,
-      maplibreMouseEvent.originalEvent
-    );
-  }
-}
-class MapSourceEvent extends MapEvent {
-  constructor(type, map, source) {
-    super(type, map);
-    __publicField$1(this, "source");
-    this.source = source;
-  }
-}
-class MapLoadingEvent extends MapEvent {
-  constructor(map, loading) {
-    super("loading", map);
-    __publicField$1(this, "loading");
-    this.loading = loading;
-  }
-}
-class MapStyleChangeEvent extends MapEvent {
-  constructor(type, map, oldStyle, newStyle) {
-    super(type, map);
-    __publicField$1(this, "oldStyle");
-    __publicField$1(this, "newStyle");
-    this.oldStyle = oldStyle;
-    this.newStyle = newStyle;
-  }
-}
-
-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;
-};
-Debug("flow:map-feature-stream");
-class MapFeatureStream {
-  constructor(options) {
-    __publicField(this, "_boundHandleLoading");
-    __publicField(this, "_boundHandleSourceFeatureState");
-    __publicField(this, "_options");
-    __publicField(this, "_sourceLoadCount", 0);
-    __publicField(this, "_sourceLoaded", true);
-    var _a;
-    this._options = {
-      fireImmediately: true,
-      ...options
-    };
-    const sourceType = options.map.getSource(options.source).type;
-    if (sourceType === "vector")
-      (_a = this._options).sourceLayer ?? (_a.sourceLayer = "geometry");
-    makeObservable(this, {
-      _options: observable,
-      _sourceLoadCount: observable,
-      featureData: computed.struct
-    });
-    this._boundHandleLoading = this.handleLoading.bind(this);
-    this._boundHandleSourceFeatureState = this.handleSourceFeatureState.bind(this);
-    onBecomeObserved(this, "featureData", this.resume.bind(this));
-    onBecomeUnobserved(this, "featureData", this.suspend.bind(this));
-  }
-  // Computed
-  get featureData() {
-    this._sourceLoadCount;
-    const featureData = this.queryFeatureData(this._options.featureIds);
-    return featureData;
-  }
-  get featureIds() {
-    return this._options.featureIds;
-  }
-  set featureIds(featureIds) {
-    runInAction(() => {
-      this._options.featureIds = featureIds;
-    });
-  }
-  subscribe(handler) {
-    const mobxSubscription = toStream(() => this.featureData, this._options.fireImmediately).subscribe(handler);
-    return {
-      unsubscribe: () => {
-        mobxSubscription.unsubscribe();
-      }
-    };
-  }
-  featureFromMaplibreFeature(feature) {
-    return {
-      id: feature.id,
-      geometry: feature.geometry,
-      source: this._options.source,
-      sourceLayer: this._options.sourceLayer,
-      properties: feature.properties,
-      state: this._options.map.maplibreMap.getFeatureState({
-        id: feature.id,
-        source: this._options.source,
-        sourceLayer: this._options.sourceLayer
-      })
-    };
-  }
-  handleLoading(event) {
-    let loaded = false;
-    if (event.type === "sourcedata" && event.sourceId === this._options.source) {
-      loaded = event.isSourceLoaded;
-    } else if (event.type === "idle") {
-      loaded = true;
-    }
-    if (this._sourceLoaded !== loaded) {
-      this._sourceLoaded = loaded;
-      if (loaded) {
-        runInAction(() => {
-          this._sourceLoadCount++;
-        });
-      }
-    }
-  }
-  handleSourceFeatureState(event) {
-    if (event.type === "sourceFeatureState" && event.source === this._options.source) {
-      runInAction(() => {
-        this._sourceLoadCount++;
-      });
-    }
-  }
-  queryFeatureData(featureIDs) {
-    if (featureIDs.length === 0) {
-      return {};
-    }
-    const featureIdProp = this._options.map.getSource(this._options.source).featureId;
-    let features = this._options.map.maplibreMap.querySourceFeatures(this._options.source, {
-      sourceLayer: this._options.sourceLayer,
-      filter: ["in", ["get", featureIdProp], ["literal", featureIDs]]
-    });
-    const ids = /* @__PURE__ */ new Set();
-    features = features.filter((feature) => ids.has(feature.id) ? false : ids.add(feature.id) && true);
-    const featureData = features.reduce((accum, f) => {
-      accum[f.id] = this.featureFromMaplibreFeature(f);
-      return accum;
-    }, {});
-    return featureData;
-  }
-  resume() {
-    this._options.map.maplibreMap.on("sourcedata", this._boundHandleLoading);
-    this._options.map.maplibreMap.on("idle", this._boundHandleLoading);
-    this._options.map.on("sourceFeatureState", this._boundHandleSourceFeatureState);
-  }
-  suspend() {
-    this._options.map.maplibreMap.off("sourcedata", this._boundHandleLoading);
-    this._options.map.maplibreMap.off("idle", this._boundHandleLoading);
-    this._options.map.off("sourceFeatureState", this._boundHandleSourceFeatureState);
-  }
-}
-
-export { FlowError as F, MapEvent as M, PluginManager as P, ReactiveExpression as R, assert as a, MapFeatureStream as b, FlowMapError as c, MapDataSource as d, MapLayer as e, MapStyleChangeEvent as f, MapSourceEvent as g, MapLoadingEvent as h, MapMouseEvent as i, die as j };