@emuanalytics/flow-rdf-core 0.0.15

package/dist/shared/flow-rdf-core.b80085b4.mjs

@@ -0,0 +1,66 @@
+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));
+
+export { isNull as a, isNil as b, capitalize as c, isDefined as d, ensureArray as e, isString as f, isStringFull as g, hasLength as h, isUndefined as i, isArray as j, isArrayFull as k, isArrayStrings as l, isObject as m, isObjectFull as n, isNumber as o, isFalse as p, isTrue as q, isIn as r, isBoolean as s, isNumeric as t, isDate as u, isValue as v, hasValue as w, isFunction as x, isPlainObject as y, isURL as z };

package/dist/shared/flow-rdf-core.bd95d618.mjs

@@ -0,0 +1,29 @@
+import { getType } from '@turf/invariant';
+import { y as isPlainObject } from './flow-rdf-core.b80085b4.mjs';
+
+const isPoint = (val) => {
+  if (!isPlainObject(val)) {
+    return false;
+  }
+  return getType(val) === "Point";
+};
+const isLineString = (val) => {
+  if (!isPlainObject(val)) {
+    return false;
+  }
+  return getType(val) === "LineString";
+};
+const isPolygon = (val) => {
+  if (!isPlainObject(val)) {
+    return false;
+  }
+  return getType(val) === "Polygon";
+};
+const isMultiPolygon = (val) => {
+  if (!val) {
+    return false;
+  }
+  return getType(val) === "MultiPolygon";
+};
+
+export { isMultiPolygon as a, isPoint as b, isPolygon as c, isLineString as i };

package/dist/shared/flow-rdf-core.c44cf082.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+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);
+  };
+}
+
+exports.debounce = debounce;
+exports.debounceWithArgs = debounceWithArgs;
+exports.memoize = memoize;
+exports.throttle = throttle;