@emuanalytics/flow-rdf-core 4.0.3 → 4.0.5

package/dist/shared/flow-rdf-core.55c169ca.cjs

@@ -1,150 +0,0 @@
-'use strict';
-
-const randomId = require('./flow-rdf-core.f50908f0.cjs');
-
-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 debounce(func, wait, options) {
-  options = {
-    leading: false,
-    trailing: true,
-    ...options
-  };
-  const leading = options.leading;
-  const trailing = options.trailing;
-  const maxWait = options.maxWait;
-  const maxing = randomId.isNumber(maxWait);
-  let lastArgs;
-  let lastThis;
-  let result;
-  let timerId;
-  let lastCallTime;
-  let lastInvokeTime = 0;
-  if (typeof func != "function") {
-    throw new TypeError("Expected a function");
-  }
-  function invokeFunc(time) {
-    const args = lastArgs;
-    const thisArg = lastThis;
-    lastArgs = lastThis = void 0;
-    lastInvokeTime = time;
-    result = func.apply(options?.context ?? thisArg, args);
-    return result;
-  }
-  function leadingEdge(time) {
-    lastInvokeTime = time;
-    timerId = setTimeout(timerExpired, wait);
-    return leading ? invokeFunc(time) : result;
-  }
-  function remainingWait(time) {
-    const timeSinceLastCall = time - lastCallTime;
-    const timeSinceLastInvoke = time - lastInvokeTime;
-    const timeWaiting = wait - timeSinceLastCall;
-    return maxing ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
-  }
-  function shouldInvoke(time) {
-    const timeSinceLastCall = time - lastCallTime;
-    const timeSinceLastInvoke = time - lastInvokeTime;
-    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
-  }
-  function timerExpired() {
-    const time = Date.now();
-    if (shouldInvoke(time)) {
-      return trailingEdge(time);
-    }
-    timerId = setTimeout(timerExpired, remainingWait(time));
-  }
-  function trailingEdge(time) {
-    timerId = void 0;
-    if (trailing && lastArgs) {
-      return invokeFunc(time);
-    }
-    lastArgs = lastThis = void 0;
-    return result;
-  }
-  function cancel() {
-    if (timerId !== void 0) {
-      clearTimeout(timerId);
-    }
-    lastInvokeTime = 0;
-    lastCallTime = 0;
-    lastArgs = lastThis = timerId = void 0;
-  }
-  function flush() {
-    return timerId === void 0 ? result : trailingEdge(Date.now());
-  }
-  function debounced(...args) {
-    const time = Date.now();
-    const isInvoking = shouldInvoke(time);
-    lastArgs = args;
-    lastThis = this;
-    lastCallTime = time;
-    if (isInvoking) {
-      if (timerId === void 0) {
-        return leadingEdge(lastCallTime);
-      }
-      if (maxing) {
-        clearTimeout(timerId);
-        timerId = setTimeout(timerExpired, wait);
-        return invokeFunc(lastCallTime);
-      }
-    }
-    if (timerId === void 0) {
-      timerId = setTimeout(timerExpired, wait);
-    }
-    return result;
-  }
-  debounced.cancel = cancel;
-  debounced.flush = flush;
-  return debounced;
-}
-function debounceWithArgs(fn, wait, options) {
-  const memoizedDebouncedFn = memoize(
-    () => debounce(fn, wait, options),
-    options
-  );
-  return (...args) => {
-    memoizedDebouncedFn(...args)(...args);
-  };
-}
-
-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);
-  };
-}
-
-exports.debounce = debounce;
-exports.debounceWithArgs = debounceWithArgs;
-exports.memoize = memoize;
-exports.throttle = throttle;
-exports.throttleWithArgs = throttleWithArgs;

package/dist/shared/flow-rdf-core.63162669.d.cts

@@ -1,10 +0,0 @@
-type Func<TArgs extends any[] = any[], TResult = any | void> = (...args: TArgs) => TResult;
-type NoReturn<T extends Func> = Func<Parameters<T>, void>;
-declare const doNotMemoize: unique symbol;
-interface MemoizeOptions<TArgs extends any[], TKey> {
-    hash?: Func<TArgs, TKey | typeof doNotMemoize>;
-    context?: any;
-}
-declare function memoize<TArgs extends any[], TResult, TKey>(originalFunction: Func<TArgs, TResult>, options: MemoizeOptions<TArgs, TKey>): (...args: TArgs) => TResult;
-
-export { type Func as F, type MemoizeOptions as M, type NoReturn as N, memoize as m };