@oscarpalmer/atoms 0.202.0 → 0.204.0

package/dist/internal/function/limit.mjs

@@ -0,0 +1,106 @@
+import { getNumberOrDefault } from "../defaults.mjs";
+//#region src/internal/function/limit.ts
+const LIMITER_NAME_ASYNC = "asyncLimiter";
+const LIMITER_NAME_SYNC = "limiter";
+const LIMITER_PROPERTY = "$limiter";
+function AsyncLimiter(type, callback, time) {
+	this[LIMITER_SYMBOL] = {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
+	};
+}
+AsyncLimiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_ASYNC;
+AsyncLimiter.prototype.cancel = cancelAsyncLimiter;
+AsyncLimiter.prototype.run = runAsyncLimiter;
+function Limiter(type, callback, time) {
+	this[LIMITER_SYMBOL] = {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
+	};
+}
+Limiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_SYNC;
+Limiter.prototype.cancel = cancelLimiter;
+Limiter.prototype.run = runLimiter;
+function cancelAsyncLimiter() {
+	const state = this[LIMITER_SYMBOL];
+	if (state.timer != null) clearTimer(state.timer);
+	if (state.last != null && !state.last.running) {
+		state.last.reject();
+		state.last = void 0;
+	}
+}
+function cancelLimiter() {
+	const { timer } = this[LIMITER_SYMBOL];
+	if (timer != null) clearTimer(timer);
+}
+function getAsyncLimiter(type, callback, time) {
+	return new AsyncLimiter(type, callback, time);
+}
+function getLimiter(type, callback, time) {
+	return new Limiter(type, callback, time);
+}
+async function handleAsyncLimiter(state, item) {
+	const now = performance.now();
+	state.start ??= now;
+	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
+		state.start = state.throttle ? now : void 0;
+		item.running = true;
+		try {
+			let result = state.callback(...item.parameters);
+			if (result instanceof Promise) result = await result;
+			item.resolve(result);
+		} catch (error) {
+			item.reject(error);
+		} finally {
+			item.running = false;
+		}
+	} else state.timer = startTimer(() => handleAsyncLimiter(state, item));
+}
+function handleLimiter(state) {
+	const now = performance.now();
+	state.start ??= now;
+	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
+		state.start = state.throttle ? now : void 0;
+		state.callback(...state.parameters);
+	} else state.timer = startTimer(() => handleLimiter(state));
+}
+function runAsyncLimiter() {
+	const state = this[LIMITER_SYMBOL];
+	cancelAsyncLimiter.call(this);
+	const next = {
+		parameters: state.parameters,
+		running: false
+	};
+	next.promise = new Promise((resolve, reject) => {
+		next.reject = reject;
+		next.resolve = resolve;
+	});
+	state.last = next;
+	if (state.throttle) handleAsyncLimiter(state, next);
+	else state.timer = startTimer(() => handleAsyncLimiter(state, next));
+	return next.promise;
+}
+function runLimiter(...parameters) {
+	const state = this[LIMITER_SYMBOL];
+	cancelLimiter.call(this);
+	state.parameters = parameters;
+	if (state.throttle) handleLimiter(state);
+	else state.timer = startTimer(() => handleLimiter(state));
+}
+const LIMITER_DEBOUNCE = "debounce";
+const LIMITER_OFFSET = 5;
+const LIMITER_SYMBOL = Symbol("limiter");
+const LIMITER_THROTTLE = "throttle";
+const LIMITER_WAIT = "wait";
+// istanbul ignore next
+const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
+// istanbul ignore next
+const startTimer = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout;
+//#endregion
+export { LIMITER_DEBOUNCE, LIMITER_THROTTLE, LIMITER_WAIT, getAsyncLimiter, getLimiter };

package/dist/internal/function/memoize.d.mts

@@ -3,7 +3,7 @@ import { GenericCallback } from "../../models.mjs";
 /**
  * A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
  */
-type Memoized<Callback extends GenericCallback> = {
+export type Memoized<Callback extends GenericCallback> = {
   /**
    * Maximum cache size
    *
@@ -58,7 +58,7 @@ type Memoized<Callback extends GenericCallback> = {
 /**
  * Options for a _Memoized_ function
  */
-type MemoizedOptions<Callback extends GenericCallback> = {
+export type MemoizedOptions<Callback extends GenericCallback> = {
   /**
    * Callback for getting a cache key for the provided parameters
    */
@@ -75,6 +75,5 @@ type MemoizedOptions<Callback extends GenericCallback> = {
  * @param options Memoization options
  * @returns _Memoized_ instance
  */
-declare function memoize<Callback extends GenericCallback>(callback: Callback, options?: MemoizedOptions<Callback>): Memoized<Callback>;
-//#endregion
-export { Memoized, MemoizedOptions, memoize };
+export declare function memoize<Callback extends GenericCallback>(callback: Callback, options?: MemoizedOptions<Callback>): Memoized<Callback>;
+//#endregion

package/dist/internal/function/memoize.mjs

@@ -3,6 +3,44 @@ import { getString, join } from "../string/misc.mjs";
 import { getNumberOrDefault } from "../defaults.mjs";
 import { SizedMap } from "../sized/map.mjs";
 //#region src/internal/function/memoize.ts
+function Memoized(callback, options) {
+	this[MEMOIZED_SYMBOL] = {
+		options,
+		cache: new SizedMap(options.cacheSize),
+		getter: void 0
+	};
+	this[MEMOIZED_SYMBOL].getter = createGetter(this[MEMOIZED_SYMBOL], callback);
+}
+Memoized.prototype.clear = clearMemoized;
+Memoized.prototype.delete = deleteMemoizedValue;
+Memoized.prototype.get = getMemoizedValue;
+Memoized.prototype.has = hasMemoizedValue;
+Memoized.prototype.run = runMemoized;
+Object.defineProperties(Memoized.prototype, {
+	maximum: {
+		enumerable: true,
+		get: getMemoizedMaximum
+	},
+	size: {
+		enumerable: true,
+		get: getMemoizedSize
+	}
+});
+function clearMemoized() {
+	this[MEMOIZED_SYMBOL].cache.clear();
+}
+function deleteMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.delete(key);
+}
+function createGetter(state, callback) {
+	return (...parameters) => {
+		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), MEMOIZED_KEY_SEPARATOR));
+		if (state.cache.has(key)) return state.cache.get(key);
+		const value = callback(...parameters);
+		state.cache.set(key, value);
+		return value;
+	};
+}
 function createMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
@@ -10,6 +48,18 @@ function createMemoizationOptions(input) {
 		cacheSize: getNumberOrDefault(cacheSize, MEMOIZED_CACHE_SIZE_DEFAULT)
 	};
 }
+function getMemoizedMaximum() {
+	return this[MEMOIZED_SYMBOL].cache.maximum;
+}
+function getMemoizedSize() {
+	return this[MEMOIZED_SYMBOL].cache.size;
+}
+function getMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.get(key);
+}
+function hasMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.has(key);
+}
 /**
 * Memoize a function, caching and retrieving results based on the first parameter
 *
@@ -19,40 +69,14 @@ function createMemoizationOptions(input) {
 */
 function memoize(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MEMOIZED_CALLBACK);
-	const state = {
-		cache: void 0,
-		getter: void 0,
-		options: createMemoizationOptions(options)
-	};
-	state.cache = new SizedMap(state.options.cacheSize);
-	state.getter = (...parameters) => {
-		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), MEMOIZED_KEY_SEPARATOR));
-		if (state.cache.has(key)) return state.cache.get(key);
-		const value = callback(...parameters);
-		state.cache.set(key, value);
-		return value;
-	};
-	const instance = {
-		clear: () => state.cache.clear(),
-		delete: (key) => state.cache.delete(key),
-		get: (key) => state.cache.get(key),
-		has: (key) => state.cache.has(key),
-		run: (...parameters) => state.getter(...parameters)
-	};
-	Object.defineProperties(instance, {
-		maximum: {
-			enumerable: true,
-			get: () => state.cache.maximum
-		},
-		size: {
-			enumerable: true,
-			get: () => state.cache.size
-		}
-	});
-	return Object.freeze(instance);
+	return new Memoized(callback, createMemoizationOptions(options));
+}
+function runMemoized(...parameters) {
+	return this[MEMOIZED_SYMBOL].getter(...parameters);
 }
 const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
 const MEMOIZED_CALLBACK = "Memoized requires a callback function";
 const MEMOIZED_KEY_SEPARATOR = "_";
+const MEMOIZED_SYMBOL = Symbol("memoized");
 //#endregion
 export { memoize };

package/dist/internal/function/misc.d.mts

@@ -2,6 +2,5 @@
 /**
  * A function that does nothing, which can be useful, I guess…
  */
-declare function noop(): void;
-//#endregion
-export { noop };
+export declare function noop(): void;
+//#endregion