@emuanalytics/flow-rdf-ui 4.0.13 → 4.0.15

package/dist/components/chart/chart.component.mjs

@@ -35,7 +35,10 @@ class FlowUiChart extends FlowRdfElement {
       this._chart.update();
     }
   }
-  firstUpdated() {
+  async connectedCallback() {
+    super.connectedCallback();
+    initializeChartJs();
+    await this.updateComplete;
     this._chart = new Chart(this._chartRef.value, {
       type: this.type,
       data: this.data,
@@ -43,10 +46,6 @@ class FlowUiChart extends FlowRdfElement {
       plugins: this.plugins
     });
   }
-  connectedCallback() {
-    super.connectedCallback();
-    initializeChartJs();
-  }
   disconnectedCallback() {
     super.disconnectedCallback();
     if (this._chart) {

package/dist/components/map/map.component.mjs

@@ -50,14 +50,17 @@ class FlowUiMap extends FlowRdfElement {
     return this._initialized;
   }
   handleCenterChange() {
+    const center = {
+      lng: this.center[0],
+      lat: this.center[1],
+      bearing: this.bearing,
+      pitch: this.pitch,
+      zoom: this.zoom
+    };
     if (this._map) {
-      this._map.setCenter({
-        lng: this.center[0],
-        lat: this.center[1],
-        bearing: this.bearing,
-        pitch: this.pitch,
-        zoom: this.zoom
-      });
+      this._map.setCenter(center);
+    } else {
+      this._pendingCenter = center;
     }
   }
   handleBaseStyleChange() {
@@ -94,6 +97,10 @@ class FlowUiMap extends FlowRdfElement {
       bearingSnap: this.bearingSnap
     });
     await map.initialized;
+    if (this._pendingCenter) {
+      map.setCenter(this._pendingCenter);
+      this._pendingCenter = void 0;
+    }
     map.on("loading", (ev) => {
       this._mapLoading = ev.loading;
     });

package/dist/components/query-builder/converters/flow-query-converters.mjs

@@ -1,7 +1,11 @@
 import { DateTime } from 'luxon';
 import { isNil, isObjectFull, isFunction } from '../../../internal/type-checks.mjs';
+import { escape } from '../../../utilities/regex.mjs';
 import { filterRuleSet, isRule, isRuleSet } from '../helpers.mjs';
 
+function isStringType(field) {
+  return field.type === "string";
+}
 function whereClausesFromRuleSet(rule, config, options) {
   if (isRule(rule)) {
     if (!rule.enabled) {
@@ -36,12 +40,14 @@ function whereClausesFromRuleSet(rule, config, options) {
   } else ;
 }
 function predicateFromRule(rule, config) {
+  const fieldConfig = config.fields[rule.field];
   const field = config.fields[rule.field];
   let operator;
   let value = rule.value;
   if (isFunction(field.convertValue)) {
     value = field.convertValue(value);
   }
+  const caseInsensitive = isStringType(fieldConfig) && fieldConfig.caseInsensitive;
   switch (rule.operator) {
     case "=":
       operator = "$eq";
@@ -68,14 +74,32 @@ function predicateFromRule(rule, config) {
       operator = "$notIn";
       break;
     case "like":
-      operator = "$iLike";
+      value = escape(String(value));
+      value = value.replace(/\\\?/g, ".");
+      value = value.replace(/\\\*/g, ".*");
+      value = `^${value}$`;
+      operator = caseInsensitive ? "$iRegexp" : "$regexp";
       break;
     case "!like":
-      operator = "$notILike";
+      value = escape(String(value));
+      value = value.replace(/\\\?/g, ".");
+      value = value.replace(/\\\*/g, ".*");
+      value = `^${value}$`;
+      operator = caseInsensitive ? "$notIRegexp" : "$notRegexp";
       break;
     case "contains":
-      operator = "$iLike";
-      value = `%${value}%`;
+      value = escape(String(value));
+      operator = caseInsensitive ? "$iRegexp" : "$regexp";
+      break;
+    case "!contains":
+      value = escape(String(value));
+      operator = caseInsensitive ? "$notIRegexp" : "$notRegexp";
+      break;
+    case "regex":
+      operator = caseInsensitive ? "$iRegexp" : "$regexp";
+      break;
+    case "!regex":
+      operator = caseInsensitive ? "$notIRegexp" : "$notRegexp";
       break;
     case "null":
       operator = "$is";
@@ -101,7 +125,11 @@ function predicateFromRule(rule, config) {
   return { [operator]: value };
 }
 const converter = (ruleset, config, options) => {
-  if (options) {
+  options = {
+    throwOnError: false,
+    ...options
+  };
+  if (options.excludeFields || options.includeFields || options.renameFields) {
     ruleset = filterRuleSet(ruleset, options);
   }
   return whereClausesFromRuleSet(ruleset, config, options);

package/dist/components/query-builder/converters/javascript-filter-converter.mjs

@@ -0,0 +1,197 @@
+import { DateTime } from 'luxon';
+import { ensureArray } from '../../../internal/ensure-array.mjs';
+import { isNil, isStringFull, isFunction } from '../../../internal/type-checks.mjs';
+import { escape } from '../../../utilities/regex.mjs';
+import { filterRuleSet, isRule, isRuleSet } from '../helpers.mjs';
+
+class JavaScriptFilterError extends Error {
+  constructor(msg) {
+    super(`JavaScriptFilter error: ${msg}`);
+  }
+}
+function isDateType(field) {
+  return field.type === "datetime" || field.type === "date" || field.type === "time";
+}
+function isStringType(field) {
+  return field.type === "string";
+}
+function convertDateTime(value, field) {
+  switch (field.type) {
+    case "datetime":
+      return +DateTime.fromISO(value);
+    case "date":
+      return +DateTime.fromISO(value).startOf("day");
+    case "time":
+      return +DateTime.fromISO(value).set({ year: 1970, day: 1, month: 1 });
+    default:
+      return 0;
+  }
+}
+function rulesetToJavascript(rule, config, options) {
+  if (isRule(rule)) {
+    if (!rule.enabled) {
+      return void 0;
+    }
+    if (isNil(rule.field) || isNil(rule.operator)) {
+      console.warn(`JavascriptFilterConverter: Skipping rule with missing field or operator`, rule);
+      return void 0;
+    }
+    const field = config.fields[rule.field];
+    if (!field) {
+      console.warn(`JavascriptFilterConverter: Skipping unknown field '${rule.field}' in rule`, rule);
+      return void 0;
+    }
+    if (isNil(rule.value) && field.nullable !== true) {
+      console.warn(`JavascriptFilterConverter: Skipping nil field '${rule.field}' in rule (non-nullable)`, rule);
+      return void 0;
+    }
+    let fieldName = rule.field;
+    if (options?.renameFields && fieldName in options.renameFields) {
+      fieldName = options.renameFields[fieldName];
+    }
+    return predicateFromRule(rule, config, options);
+  } else if (isRuleSet(rule)) {
+    const condition = rule.condition === "and" ? " && " : " || ";
+    const rules = rule.rules.map((r) => rulesetToJavascript(r, config, options)).filter((r) => isStringFull(r));
+    return rules.length ? rules.map((r) => `(${r})`).join(condition) : "true";
+  } else ;
+}
+function predicateFromRule(rule, config, options) {
+  const fieldConfig = config.fields[rule.field];
+  let predicate;
+  let fieldName = rule.field;
+  if (options.renameFields && fieldName in options.renameFields) {
+    fieldName = options.renameFields[fieldName];
+  }
+  let field = `get("${fieldName}", data)`;
+  let operator = "";
+  let value = rule.value;
+  if (isFunction(fieldConfig.convertValue)) {
+    value = fieldConfig.convertValue(value);
+  }
+  if (isDateType(fieldConfig)) {
+    value = convertDateTime(value, fieldConfig);
+  }
+  const caseInsensitive = isStringType(fieldConfig) && !!fieldConfig.caseInsensitive;
+  switch (rule.operator) {
+    case "=":
+      operator = "==";
+      break;
+    case "!=":
+      operator = "!=";
+      break;
+    case "<":
+      operator = "<";
+      break;
+    case "<=":
+      operator = "<=";
+      break;
+    case ">":
+      operator = ">";
+      break;
+    case ">=":
+      operator = ">=";
+      break;
+    case "in":
+      value = ensureArray(value);
+      predicate = `[${value.map(JSON.stringify).join(", ")}].includes(${field})`;
+      break;
+    case "!in":
+      value = ensureArray(value);
+      predicate = `![${value.map(JSON.stringify).join(", ")}].includes(${field})`;
+      break;
+    case "contains":
+      field = caseInsensitive ? `${field}.toLowerCase()` : field;
+      value = caseInsensitive ? String(value).toLowerCase() : value;
+      predicate = `${field}.includes(${JSON.stringify(value)})`;
+      break;
+    case "!contains":
+      field = caseInsensitive ? `${field}.toLowerCase()` : field;
+      value = caseInsensitive ? String(value).toLowerCase() : value;
+      predicate = `!(${field}.includes(${JSON.stringify(value)}))`;
+      break;
+    case "like":
+      value = escape(String(value));
+      value = value.replace(/\\\?/g, ".");
+      value = value.replace(/\\\*/g, ".*");
+      value = `^${value}$`;
+      predicate = `regex(${JSON.stringify(value)}, ${field}, ${caseInsensitive})`;
+      break;
+    case "!like":
+      value = escape(String(value));
+      value = value.replace(/\\\?/g, ".");
+      value = value.replace(/\\\*/g, ".*");
+      value = `^${value}$`;
+      predicate = `!(regex(${JSON.stringify(value)}, ${field}, ${caseInsensitive}))`;
+      break;
+    case "regex":
+      predicate = `regex(${JSON.stringify(value)}, ${field}, ${caseInsensitive})`;
+      break;
+    case "!regex":
+      predicate = `!(regex(${JSON.stringify(value)}, ${field}, ${caseInsensitive}))`;
+      break;
+    default:
+      throw new Error(`Unrecognized query operator '${rule.operator}'`);
+  }
+  predicate ?? (predicate = `${field} ${operator} ${JSON.stringify(value)}`);
+  return predicate;
+}
+const converter = (ruleset, config, options) => {
+  const warnings = {};
+  const regExps = {};
+  options = {
+    throwOnError: false,
+    ...options
+  };
+  if (options.excludeFields || options.includeFields || options.renameFields) {
+    ruleset = filterRuleSet(ruleset, options);
+  }
+  const hasOwnProperty = (obj, prop) => {
+    if (typeof obj === "object" || typeof obj === "function") {
+      return Object.prototype.hasOwnProperty.call(obj, prop);
+    }
+    return false;
+  };
+  const getProp = (prop, obj) => {
+    if (!config.fields[prop])
+      throw new JavaScriptFilterError(`Unknown query builder field "${prop}"`);
+    if (!hasOwnProperty(obj ?? {}, prop))
+      throw new JavaScriptFilterError(`Missing property "${prop}" in supplied data object`);
+    const fieldConfig = config.fields[prop];
+    let value = obj[prop];
+    if (isDateType(fieldConfig)) {
+      value = convertDateTime(value, fieldConfig);
+    }
+    if (isStringType(fieldConfig) && fieldConfig.caseInsensitive) {
+      value = String(value).toLowerCase();
+    }
+    return value;
+  };
+  const regex = (regex2, val, caseInsensitive = false) => {
+    if (!regExps[regex2]) {
+      regExps[regex2] = new RegExp(regex2, caseInsensitive ? "i" : "");
+    }
+    return regExps[regex2].test(val);
+  };
+  const js = ["return ", rulesetToJavascript(ruleset, config, options), ";"];
+  const func = new Function("get", "regex", "data", js.join(""));
+  const wrappedFunction = (data) => {
+    try {
+      return func(getProp, regex, data);
+    } catch (e) {
+      if (!warnings[e.message]) {
+        warnings[e.message] = true;
+        console.warn(e.message);
+      }
+      if (options?.throwOnError) {
+        throw e;
+      }
+      return false;
+    }
+  };
+  wrappedFunction.expression = js.join("");
+  return wrappedFunction;
+};
+const converter$1 = converter;
+
+export { JavaScriptFilterError, converter$1 as default };

package/dist/components/query-builder/converters/map-layer-filter-converter.mjs

@@ -1,7 +1,11 @@
 import { ensureArray } from '../../../internal/ensure-array.mjs';
 import { isNil, isStringFull, isFunction } from '../../../internal/type-checks.mjs';
+import { escape } from '../../../utilities/regex.mjs';
 import { filterRuleSet, isRule, isRuleSet } from '../helpers.mjs';
 
+function isStringType(field) {
+  return field.type === "string";
+}
 function mapLayerFilterFromRuleSet(rule, config, options) {
   if (isRule(rule)) {
     if (!rule.enabled) {
@@ -24,22 +28,28 @@ function mapLayerFilterFromRuleSet(rule, config, options) {
     if (options?.renameFields && fieldName in options.renameFields) {
       fieldName = options.renameFields[fieldName];
     }
-    return predicateFromRule(rule, config);
+    return predicateFromRule(rule, config, options);
   } else if (isRuleSet(rule)) {
     const condition = rule.condition === "and" ? " && " : " || ";
     const rules = rule.rules.map((r) => mapLayerFilterFromRuleSet(r, config, options)).filter((r) => isStringFull(r));
-    return rules.length ? rules.map((r) => `(${r})`).join(condition) : "";
+    return rules.length ? rules.map((r) => `(${r})`).join(condition) : "true";
   } else ;
 }
-function predicateFromRule(rule, config) {
+function predicateFromRule(rule, config, options) {
   const fieldConfig = config.fields[rule.field];
+  let fieldName = rule.field;
+  if (options.renameFields && fieldName in options.renameFields) {
+    fieldName = options.renameFields[fieldName];
+  }
   let predicate;
-  const field = `get("${rule.field}")`;
+  let field = `get("${fieldName}")`;
   let operator = "";
   let value = rule.value;
+  let negate = false;
   if (isFunction(fieldConfig.convertValue)) {
     value = fieldConfig.convertValue(value);
   }
+  const caseInsensitive = isStringType(fieldConfig) && fieldConfig.caseInsensitive;
   switch (rule.operator) {
     case "=":
       operator = "==";
@@ -68,28 +78,53 @@ function predicateFromRule(rule, config) {
       predicate = `!in(${field}, literal([${value.map(JSON.stringify).join(", ")}]))`;
       break;
     case "like":
-      operator = "~*";
+      value = escape(String(value));
+      value = value.replace(/\\\?/g, ".");
+      value = value.replace(/\\\*/g, ".*");
+      value = `^${value}$`;
+      operator = caseInsensitive ? "~*" : "~";
+      break;
+    case "!like":
+      value = escape(String(value));
+      value = value.replace(/\\\?/g, ".");
+      value = value.replace(/\\\*/g, ".*");
+      value = `^${value}$`;
+      operator = caseInsensitive ? "~*" : "~";
+      negate = true;
       break;
     case "contains":
+      field = caseInsensitive ? `downcase(${field})` : field;
+      value = caseInsensitive ? String(value).toLowerCase() : value;
       predicate = `in(${JSON.stringify(value)}, ${field})`;
       break;
-    case "=i":
-      operator = "=*";
+    case "!contains":
+      field = caseInsensitive ? `downcase(${field})` : field;
+      value = caseInsensitive ? String(value).toLowerCase() : value;
+      predicate = `in(${JSON.stringify(value)}, ${field})`;
+      negate = true;
       break;
     case "regex":
-      operator = "~";
+      operator = caseInsensitive ? "~*" : "~";
       break;
-    case "regexi":
-      operator = "~*";
+    case "!regex":
+      operator = caseInsensitive ? "~*" : "~";
+      negate = true;
       break;
     default:
       throw new Error(`Unrecognized query operator '${rule.operator}'`);
   }
   predicate ?? (predicate = `${field} ${operator} ${JSON.stringify(value)}`);
+  if (negate) {
+    predicate = `!(${predicate})`;
+  }
   return predicate;
 }
 const converter = (ruleset, config, options) => {
-  if (options) {
+  options = {
+    throwOnError: false,
+    ...options
+  };
+  if (options.excludeFields || options.includeFields || options.renameFields) {
     ruleset = filterRuleSet(ruleset, options);
   }
   return mapLayerFilterFromRuleSet(ruleset, config, options);

package/dist/components/query-builder/query-builder.component.mjs

@@ -440,7 +440,7 @@ __decorateClass([
 let FlowUiQueryBuilder = _FlowUiQueryBuilder;
 FlowUiQueryBuilder.registerFieldDefinition("string", {
   template: defaultStringTemplate,
-  operators: ["=", "!=", "like", "contains"]
+  operators: ["=", "!=", "contains", "like", "regex"]
 });
 FlowUiQueryBuilder.registerFieldDefinition("number", {
   template: defaultNumberTemplate,