@emuanalytics/flow-rdf-core 4.0.4 → 4.0.6

package/dist/lib/utils/decorators.mjs

@@ -0,0 +1,59 @@
+import { die } from './assert.mjs';
+
+const storedAnnotationsSymbol = Symbol("flow-rdf-annotations");
+function createDecoratorAnnotation(annotation) {
+  function decorator(target, property) {
+    storeAnnotation(target, property, annotation);
+  }
+  return Object.assign(decorator, annotation);
+}
+function createDecoratorAnnotationWithArg(annotation) {
+  function decorator(target, property) {
+    storeAnnotation(target, property, annotation);
+  }
+  return (arg) => {
+    annotation = Object.assign({}, annotation, { arg });
+    return Object.assign(decorator, annotation);
+  };
+}
+function storeAnnotation(prototype, key, annotation) {
+  var _a, _b;
+  if (!hasProp(prototype, storedAnnotationsSymbol)) {
+    addHiddenProp(prototype, storedAnnotationsSymbol, {
+      // Inherit annotations
+      ...prototype[storedAnnotationsSymbol]
+    });
+  }
+  (_a = prototype[storedAnnotationsSymbol])[_b = annotation.annotationType] ?? (_a[_b] = {});
+  assertNotDecorated(prototype, annotation, key);
+  prototype[storedAnnotationsSymbol][annotation.annotationType][key] = annotation;
+}
+function assertNotDecorated(prototype, annotation, key) {
+  if (hasProp(prototype[storedAnnotationsSymbol][annotation.annotationType], key)) {
+    const fieldName = `${prototype.constructor.name}.prototype.${key.toString()}`;
+    const currentAnnotationType = prototype[storedAnnotationsSymbol][key].annotationType_;
+    const requestedAnnotationType = annotation.annotationType;
+    die(
+      `Cannot apply '@${requestedAnnotationType}' to '${fieldName}':
+The field is already decorated with '@${currentAnnotationType}'.
+Re-decorating fields is not allowed.
+Use '@override' decorator for methods overridden by subclass.`
+    );
+  }
+}
+function collectStoredAnnotations(target, annotationType) {
+  return target[storedAnnotationsSymbol]?.[annotationType] ?? {};
+}
+function addHiddenProp(object, propName, value) {
+  Object.defineProperty(object, propName, {
+    enumerable: false,
+    writable: true,
+    configurable: true,
+    value
+  });
+}
+function hasProp(target, prop) {
+  return Object.hasOwnProperty.call(target, prop);
+}
+
+export { addHiddenProp, collectStoredAnnotations, createDecoratorAnnotation, createDecoratorAnnotationWithArg, hasProp, storeAnnotation, storedAnnotationsSymbol };

package/dist/lib/utils/deferred.mjs

@@ -0,0 +1,11 @@
+import { WatchablePromise } from './watchable-promise.mjs';
+
+function deferred() {
+  let methods;
+  const promise = new WatchablePromise((resolve, reject) => {
+    methods = { resolve, reject };
+  });
+  return Object.assign(promise, methods);
+}
+
+export { deferred };

package/dist/lib/utils/ensure-array.mjs

@@ -0,0 +1,16 @@
+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);
+}
+
+export { ensureArray };

package/dist/{shared/flow-rdf-core.1f0901c5.mjs → lib/utils/feature-type-checks.mjs}

@@ -1,5 +1,5 @@
 import { getType } from '@turf/invariant';
-import { y as isPlainObject } from './flow-rdf-core.25e5f6d7.mjs';
+import { isPlainObject } from './type-checks.mjs';
 
 const isPoint = (val) => {
   if (!isPlainObject(val)) {
@@ -26,4 +26,4 @@ const isMultiPolygon = (val) => {
   return getType(val) === "MultiPolygon";
 };
 
-export { isMultiPolygon as a, isPoint as b, isPolygon as c, isLineString as i };
+export { isLineString, isMultiPolygon, isPoint, isPolygon };

package/dist/lib/utils/functional.mjs

@@ -0,0 +1,22 @@
+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;
+  };
+}
+
+export { doNotMemoize, memoize };

package/dist/lib/utils/global.mjs

@@ -0,0 +1,18 @@
+const mockGlobal = {};
+function getGlobal() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  return mockGlobal;
+}
+
+export { getGlobal };

package/dist/lib/utils/index.mjs

@@ -1,6 +1,9 @@
-export { c as capitalize, e as ensureArray, h as hasLength, w as hasValue, j as isArray, k as isArrayFull, l as isArrayStrings, s as isBoolean, u as isDate, d as isDefined, p as isFalse, x as isFunction, r as isIn, b as isNil, a as isNull, o as isNumber, t as isNumeric, m as isObject, n as isObjectFull, y as isPlainObject, f as isString, g as isStringFull, q as isTrue, z as isURL, i as isUndefined, v as isValue, A as randomId } from '../../shared/flow-rdf-core.25e5f6d7.mjs';
-export { i as isLineString, a as isMultiPolygon, b as isPoint, c as isPolygon } from '../../shared/flow-rdf-core.1f0901c5.mjs';
-export { d as debounce, a as debounceWithArgs, m as memoize, t as throttle, b as throttleWithArgs } from '../../shared/flow-rdf-core.187cb345.mjs';
+export { hasLength, hasValue, isArray, isArrayFull, isArrayStrings, isBoolean, isDate, isDefined, isFalse, isFunction, isIn, isNil, isNull, isNumber, isNumeric, isObject, isObjectFull, isPlainObject, isString, isStringFull, isTrue, isURL, isUndefined, isValue } from './type-checks.mjs';
+export { ensureArray } from './ensure-array.mjs';
+export { isLineString, isMultiPolygon, isPoint, isPolygon } from './feature-type-checks.mjs';
+export { memoize } from './functional.mjs';
+export { debounce, debounceWithArgs } from './debounce.mjs';
+export { throttle, throttleWithArgs } from './throttle.mjs';
+export { capitalize } from './string-utils.mjs';
+export { randomId } from './random-id.mjs';
 export { html } from 'lit-html';
-import 'nanoid';
-import '@turf/invariant';

package/dist/lib/utils/random-id.mjs

@@ -0,0 +1,9 @@
+import { customAlphabet } from 'nanoid';
+
+const nanoid = customAlphabet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01923456789", 10);
+function randomId(prefix, length) {
+  const id = nanoid(length);
+  return prefix ? `${prefix}-${id}` : id;
+}
+
+export { randomId };

package/dist/lib/utils/string-utils.mjs

@@ -0,0 +1,3 @@
+const capitalize = (str, lowerRest = false) => str.slice(0, 1).toUpperCase() + (lowerRest ? str.slice(1).toLowerCase() : str.slice(1));
+
+export { capitalize };

package/dist/lib/utils/throttle.mjs

@@ -0,0 +1,20 @@
+import { debounce } from './debounce.mjs';
+import { memoize } from './functional.mjs';
+
+function throttle(func, wait, options) {
+  if (typeof func != "function") {
+    throw new TypeError("Expected a function");
+  }
+  return debounce(func, wait, { ...options, maxWait: wait });
+}
+function throttleWithArgs(fn, wait, options) {
+  const memoizedThrottleFn = memoize(
+    () => debounce(fn, wait, options),
+    options
+  );
+  return (...args) => {
+    memoizedThrottleFn(...args)(...args);
+  };
+}
+
+export { throttle as default, throttle, throttleWithArgs };

package/dist/{shared/flow-rdf-core.25e5f6d7.mjs → lib/utils/type-checks.mjs}

@@ -1,5 +1,3 @@
-import { customAlphabet } from 'nanoid';
-
 const isUndefined = (val) => typeof val === "undefined";
 const isNull = (val) => val === null;
 const isNil = (val) => isUndefined(val) || isNull(val);
@@ -48,27 +46,4 @@ 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));
-
-const nanoid = customAlphabet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01923456789", 10);
-function randomId(prefix, length) {
-  const id = nanoid(length);
-  return prefix ? `${prefix}-${id}` : id;
-}
-
-export { randomId as A, 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 };
+export { hasLength, hasValue, isArray, isArrayFull, isArrayStrings, isBoolean, isDate, isDefined, isFalse, isFunction, isIn, isNil, isNull, isNumber, isNumeric, isObject, isObjectFull, isPlainObject, isString, isStringFull, isTrue, isURL, isUndefined, isValue };

package/dist/lib/utils/watchable-promise.mjs

@@ -0,0 +1,55 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _value, _settled, _status;
+class WatchablePromise extends Promise {
+  constructor(executor) {
+    super((resolve, reject) => {
+      executor(
+        (value) => {
+          resolve(value);
+          __privateSet(this, _value, value);
+          __privateSet(this, _settled, true);
+          __privateSet(this, _status, "fulfilled");
+        },
+        (reason) => {
+          reject(reason);
+          __privateSet(this, _settled, true);
+          __privateSet(this, _status, "rejected");
+        }
+      );
+    });
+    __privateAdd(this, _value, void 0);
+    __privateAdd(this, _settled, false);
+    __privateAdd(this, _status, "pending");
+  }
+  get settled() {
+    return __privateGet(this, _settled);
+  }
+  get status() {
+    return __privateGet(this, _status);
+  }
+  get value() {
+    return __privateGet(this, _value);
+  }
+}
+_value = new WeakMap();
+_settled = new WeakMap();
+_status = new WeakMap();
+
+export { WatchablePromise };

package/dist/package.json.mjs

@@ -0,0 +1,3 @@
+const version = "4.0.6";
+
+export { version };