@emuanalytics/flow-rdf-core 0.0.15

package/dist/shared/flow-rdf-core.2e456f93.mjs

@@ -0,0 +1,83 @@
+const doNotMemoize = Symbol("Do not memoize");
+function memoize(originalFunction, options) {
+  const cache = /* @__PURE__ */ new Map();
+  const hash = options.hash ? options.hash : (...args) => args[0];
+  const context = options.context;
+  return function memoizedFunction(...args) {
+    const key = hash.apply(context, args);
+    if (key === doNotMemoize) {
+      return originalFunction.apply(context, args);
+    }
+    let value;
+    if (!cache.has(key)) {
+      value = originalFunction.apply(context, args);
+      cache.set(key, value);
+    } else {
+      value = cache.get(key);
+    }
+    return value;
+  };
+}
+function throttle(callback, options) {
+  const { delay, noTrailing = false, noLeading = false, debounceMode = void 0 } = options;
+  let timeoutID;
+  let cancelled = false;
+  let lastExec = 0;
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+  }
+  function cancel(options2) {
+    const { upcomingOnly = false } = options2 || {};
+    clearExistingTimeout();
+    cancelled = !upcomingOnly;
+  }
+  function wrapper(...arguments_) {
+    const context = options.context;
+    const elapsed = Date.now() - lastExec;
+    if (cancelled) {
+      return;
+    }
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(context, arguments_);
+    }
+    function clear() {
+      timeoutID = void 0;
+    }
+    if (!noLeading && debounceMode && !timeoutID) {
+      exec();
+    }
+    clearExistingTimeout();
+    if (debounceMode === void 0 && elapsed > delay) {
+      if (noLeading) {
+        lastExec = Date.now();
+        if (!noTrailing) {
+          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+        }
+      } else {
+        exec();
+      }
+    } else if (noTrailing !== true) {
+      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === void 0 ? delay - elapsed : delay);
+    }
+  }
+  wrapper.cancel = cancel;
+  return wrapper;
+}
+function debounce(callback, options) {
+  const { delay, context, atBegin = false } = options;
+  return throttle(callback, { delay, debounceMode: atBegin !== false, context });
+}
+function debounceWithArgs(fn, options) {
+  const memoizedDebouncedFn = memoize(
+    () => debounce(fn, options),
+    options
+  );
+  return (...args) => {
+    memoizedDebouncedFn(...args)(...args);
+  };
+}
+
+export { debounceWithArgs as a, debounce as d, memoize as m, throttle as t };

package/dist/shared/flow-rdf-core.3042be4a.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+const isUndefined = (val) => typeof val === "undefined";
+const isNull = (val) => val === null;
+const isNil = (val) => isUndefined(val) || isNull(val);
+const isDefined = (val) => !isNil(val);
+const isString = (val) => typeof val === "string";
+const hasLength = (val) => isDefined(val) && val.length > 0;
+const isStringFull = (val) => isString(val) && hasLength(val);
+const isArray = (val) => Array.isArray(val);
+const isArrayFull = (val) => Array.isArray(val) && hasLength(val);
+const isArrayStrings = (val) => isArrayFull(val) && val.every((v) => isStringFull(v));
+const isObject = (val) => typeof val === "object" && !isNull(val);
+const isObjectFull = (val) => isObject(val) && hasLength(Object.keys(val));
+const isNumber = (val) => typeof val === "number" && !Number.isNaN(val) && Number.isFinite(val);
+const isFalse = (val) => val === false;
+const isTrue = (val) => val === true;
+const isIn = (val, arr) => isArrayFull(arr) && arr.some((o) => val === o);
+const isBoolean = (val) => typeof val === "boolean";
+const isNumeric = (val) => isString(val) && /^[+-]?([0-9]*[.])?[0-9]+$/.test(val);
+const isDate = (val) => val instanceof Date;
+const isValue = (val) => isStringFull(val) || isNumber(val) || isBoolean(val) || isDate(val);
+const hasValue = (val) => isArrayFull(val) ? val.every((o) => isValue(o)) : isValue(val);
+const isFunction = (val) => typeof val === "function";
+function isPlainObject(o) {
+  if (!isObject(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (isObject(prot) === false) {
+    return false;
+  }
+  if (prot.hasOwnProperty("isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+const urlRegex = new RegExp(
+  "^(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*(\\?[;&a-z\\d%_.~+=-]*)?(\\#[-a-z\\d_]*)?$",
+  // fragment locator
+  "i"
+);
+function isURL(val) {
+  return isString(val) && !!urlRegex.test(val);
+}
+
+function ensureArray(a, ...rest) {
+  if (arguments.length === 0) {
+    return [];
+  }
+  if (arguments.length === 1) {
+    if (a === void 0 || a === null) {
+      return [];
+    }
+    if (Array.isArray(a)) {
+      return a;
+    }
+  }
+  return Array.prototype.slice.call(arguments);
+}
+
+const capitalize = (str, lowerRest = false) => str.slice(0, 1).toUpperCase() + (lowerRest ? str.slice(1).toLowerCase() : str.slice(1));
+
+exports.capitalize = capitalize;
+exports.ensureArray = ensureArray;
+exports.hasLength = hasLength;
+exports.hasValue = hasValue;
+exports.isArray = isArray;
+exports.isArrayFull = isArrayFull;
+exports.isArrayStrings = isArrayStrings;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isDefined = isDefined;
+exports.isFalse = isFalse;
+exports.isFunction = isFunction;
+exports.isIn = isIn;
+exports.isNil = isNil;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isNumeric = isNumeric;
+exports.isObject = isObject;
+exports.isObjectFull = isObjectFull;
+exports.isPlainObject = isPlainObject;
+exports.isString = isString;
+exports.isStringFull = isStringFull;
+exports.isTrue = isTrue;
+exports.isURL = isURL;
+exports.isUndefined = isUndefined;
+exports.isValue = isValue;

package/dist/shared/flow-rdf-core.84eded74.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const invariant = require('@turf/invariant');
+const stringUtils = require('./flow-rdf-core.3042be4a.cjs');
+
+const isPoint = (val) => {
+  if (!stringUtils.isPlainObject(val)) {
+    return false;
+  }
+  return invariant.getType(val) === "Point";
+};
+const isLineString = (val) => {
+  if (!stringUtils.isPlainObject(val)) {
+    return false;
+  }
+  return invariant.getType(val) === "LineString";
+};
+const isPolygon = (val) => {
+  if (!stringUtils.isPlainObject(val)) {
+    return false;
+  }
+  return invariant.getType(val) === "Polygon";
+};
+const isMultiPolygon = (val) => {
+  if (!val) {
+    return false;
+  }
+  return invariant.getType(val) === "MultiPolygon";
+};
+
+exports.isLineString = isLineString;
+exports.isMultiPolygon = isMultiPolygon;
+exports.isPoint = isPoint;
+exports.isPolygon = isPolygon;