lissa 1.0.0

package/lib/utils/OpenPromise.js

@@ -0,0 +1,88 @@
+export default class OpenPromise extends Promise {
+	#resolveSelf;
+	#rejectSelf;
+
+	#listeners;
+
+	#status;
+	#value;
+	#reason;
+
+	constructor(executor = () => {}) {
+		let resolve, reject;
+		super((res, rej) => {
+			resolve = res;
+			reject = rej;
+			return executor(res, rej);
+		});
+		this.#resolveSelf = resolve;
+		this.#rejectSelf = reject;
+
+		this.#listeners = new Map([
+			['resolve', new Set()],
+			['reject', new Set()],
+			['settle', new Set()],
+		]);
+
+		this.#status = 'pending';
+	}
+
+	get status() {
+		return this.#status;
+	}
+
+	get value() {
+		return this.#value;
+	}
+
+	get reason() {
+		return this.#reason;
+	}
+
+	on(event, listener) {
+		this.#listeners.get(event)?.add(listener);
+		return this;
+	}
+
+	off(event, listener) {
+		this.#listeners.get(event)?.delete(listener);
+		return this;
+	}
+
+	#emit(event, value) {
+		this.#listeners.get(event).forEach(listener => listener(value));
+	}
+
+	resolve(value) {
+		if (this.#status !== 'pending') return;
+
+		this.#status = 'fulfilled';
+		this.#value = value;
+
+		this.#emit('resolve', value);
+		this.#emit('settle', {
+			status: 'fulfilled',
+			value,
+		});
+
+		this.#resolveSelf(value);
+		this.#listeners.clear();
+	}
+
+	reject(reason) {
+		if (this.#status !== 'pending') return;
+
+		this.#status = 'rejected';
+		this.#reason = reason;
+
+		this.#emit('reject', reason);
+		this.#emit('settle', {
+			status: 'rejected',
+			reason,
+		});
+
+		this.#rejectSelf(reason);
+		this.#listeners.clear();
+	}
+
+}

package/lib/utils/helper.js

@@ -0,0 +1,195 @@
+export function normalizeOptions(options = {}) {
+	const { get = {}, post = {}, put = {}, patch = {}, delete: del = {}, ...defaults } = options;
+
+	function normalize(options) {
+		const normalized = { ...options };
+		normalized.headers = new Headers(options.headers || {});
+		normalized.params = options.params || {};
+		return normalized;
+	}
+
+	return {
+		...normalize(defaults),
+		'get': normalize(get),
+		'post': normalize(post),
+		'put': normalize(put),
+		'patch': normalize(patch),
+		'delete': normalize(del),
+	};
+}
+
+export function deepMerge(...objects) {
+	let merged;
+
+	for (const obj of objects) {
+		if (obj == null) continue;
+
+		if (obj instanceof AbortSignal) {
+			if (!merged) merged = obj;
+			else merged = AbortSignal.any([merged, obj]);
+			continue;
+		}
+
+		if (obj instanceof Headers) {
+			merged = new Headers(merged);
+
+			obj.forEach((value, key) => {
+				merged.set(key, value);
+			});
+
+			continue;
+		}
+
+		if (Array.isArray(obj)) {
+			merged = [...(merged || []), ...obj];
+			continue;
+		}
+
+		if (typeof obj === 'object' && obj.constructor === Object) {
+			merged = merged || {};
+
+			Object.keys(obj).forEach((key) => {
+				merged[key] = deepMerge(merged[key], obj[key]);
+			});
+
+			continue;
+		}
+
+		merged = obj;
+	}
+
+	return merged;
+}
+
+export function stringToBase64(str) {
+	// Browser environment
+	if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
+		let binary = '';
+		new TextEncoder().encode(str).forEach((byte) => {
+			binary += String.fromCharCode(byte);
+		});
+		return window.btoa(binary);
+	}
+
+	// Node.js environment
+	if (typeof Buffer !== 'undefined') {
+		return Buffer.from(str, 'utf-8').toString('base64');
+	}
+
+	throw new Error('Base64 encoding not supported in this environment');
+}
+
+export function stringifyParams(params, serializer) {
+	if (typeof serializer === 'function') return serializer(params);
+	if (serializer === 'extended') return extendedParamsSerializer(params);
+	return simpleParamsSerializer(params);
+}
+
+export function simpleParamsSerializer(params) {
+
+	function stringifyPrimitive(v) {
+		switch (typeof v) {
+			case 'string': return encodeURIComponent(v);
+			case 'number': return Number.isFinite(v) ? `${v}` : '';
+			case 'bigint':
+			case 'boolean': return `${v}`;
+			default: return '';
+		}
+	}
+
+	function* generator(params) {
+		for (const [key, val] of Object.entries(params)) {
+			if (Array.isArray(val)) {
+				for (const arrVal of val) {
+					yield `${encodeURIComponent(key)}=${stringifyPrimitive(arrVal)}`;
+				}
+			}
+			else {
+				yield `${encodeURIComponent(key)}=${stringifyPrimitive(val)}`;
+			}
+		}
+	}
+
+	return generator(params).toArray().join('&');
+}
+
+export function extendedParamsSerializer(params) {
+
+	function* recursiveGenerator(key, value) {
+		if (value === null) {
+			return yield `${key}=`;
+		}
+
+		const type = typeof value;
+
+		if (type === 'object' && value instanceof Date) {
+			yield `${key}=${encodeURIComponent(value.toISOString())}`;
+		}
+		else if (type === 'object') {
+			for (const [subKey, val] of Object.entries(value)) {
+				yield* recursiveGenerator(`${key}%5B${encodeURIComponent(subKey)}%5D`, val);
+			}
+		}
+		else if (type === 'string') {
+			yield `${key}=${encodeURIComponent(value)}`;
+		}
+		else if (type === 'number' || type === 'bigint' || type === 'boolean') {
+			yield `${key}=${value}`;
+		}
+	}
+
+	function* startGenerator(params) {
+		for (const [key, val] of Object.entries(params)) {
+			yield* recursiveGenerator(encodeURIComponent(key), val);
+		}
+	}
+
+	return startGenerator(params).toArray().join('&');
+}
+
+export function resolveCause(error, last) {
+	const data = {};
+
+	function* getStack(error) {
+		if (!error) return;
+		Object.assign(data, error);
+
+		yield error.stack;
+		yield* getStack(error.cause);
+	}
+
+	error.stack = [
+		...getStack(error),
+		...getStack(last),
+	].join('\nCaused by ');
+
+	delete error.cause;
+
+	Object.entries(data).forEach(([key, value]) => {
+		if (key in error || key === 'name') return;
+		error[key] = value;
+	});
+
+	return error;
+}
+
+export function throttle(fn, delay = 50) {
+	let lastCall = 0;
+	let timeoutId;
+
+	return (...args) => {
+		const now = performance.now();
+
+		if (now - lastCall >= delay) {
+			lastCall = now;
+			fn.apply(this, args);
+		}
+		else {
+			clearTimeout(timeoutId);
+			timeoutId = setTimeout(() => {
+				lastCall = performance.now();
+				fn.apply(this, args);
+			}, delay - (now - lastCall));
+		}
+	};
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "lissa",
+  "version": "1.0.0",
+  "description": "A lightweight, extensible HTTP client for modern JavaScript applications with fluent api syntax, hooks, plugins and more.",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "start": "npm run dev",
+    "dev": "nodemon examples/index.js --exec \"npm run lint && node\"",
+    "dev:inspect": "nodemon --inspect-brk examples/index.js",
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "pub": "node scripts/publish.js",
+    "pub:patch": "npm version patch",
+    "pub:feature": "npm version minor",
+    "preversion": "npm run lint",
+    "postversion": "git push && git push --tags"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/richterdennis/lissa.git"
+  },
+  "keywords": [
+    "http",
+    "https",
+    "request",
+    "client",
+    "fetch",
+    "api",
+    "rest",
+    "ajax",
+    "xhr",
+    "promise",
+    "async",
+    "await",
+    "fluent",
+    "plugin",
+    "retry",
+    "dedupe",
+    "deduplication",
+    "upload",
+    "download",
+    "progress",
+    "timeout",
+    "abort",
+    "browser",
+    "node",
+    "universal",
+    "typescript",
+    "lightweight",
+    "zero-dependencies",
+    "modular",
+    "extensible"
+  ],
+  "author": "Dennis Richter <lissa@richterdennis.de>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/richterdennis/lissa/issues"
+  },
+  "homepage": "https://github.com/richterdennis/lissa#readme",
+  "devDependencies": {
+    "@eslint/js": "9.34.0",
+    "@stylistic/eslint-plugin": "5.3.1",
+    "eslint": "9.34.0",
+    "express": "^5.1.0",
+    "globals": "^16.3.0",
+    "lissa": "file:",
+    "nodemon": "^3.1.10",
+    "prompts": "^2.4.2"
+  }
+}