@atom-forge/rpc 0.3.2

package/dist/util/cookies.js

@@ -0,0 +1,54 @@
+function parseCookieHeader(header) {
+    const map = new Map();
+    for (const pair of header.split(";")) {
+        const idx = pair.indexOf("=");
+        if (idx === -1)
+            continue;
+        const name = pair.slice(0, idx).trim();
+        const value = pair.slice(idx + 1).trim();
+        if (name)
+            map.set(name, decodeURIComponent(value));
+    }
+    return map;
+}
+function serializeCookie(name, value, options = {}) {
+    let str = `${name}=${encodeURIComponent(value)}`;
+    if (options.maxAge != null)
+        str += `; Max-Age=${Math.floor(options.maxAge)}`;
+    if (options.expires)
+        str += `; Expires=${options.expires.toUTCString()}`;
+    if (options.path != null)
+        str += `; Path=${options.path}`;
+    else
+        str += "; Path=/";
+    if (options.domain)
+        str += `; Domain=${options.domain}`;
+    if (options.secure)
+        str += "; Secure";
+    if (options.httpOnly)
+        str += "; HttpOnly";
+    if (options.sameSite)
+        str += `; SameSite=${options.sameSite}`;
+    return str;
+}
+export class CookieManager {
+    constructor(requestHeaders, responseHeaders) {
+        this.requestHeaders = requestHeaders;
+        this.responseHeaders = responseHeaders;
+        this.parsed = parseCookieHeader(requestHeaders.get("Cookie") || "");
+    }
+    get(name) {
+        return this.parsed.get(name);
+    }
+    getAll() {
+        return Array.from(this.parsed.entries()).map(([name, value]) => ({ name, value }));
+    }
+    set(name, value, options) {
+        this.parsed.set(name, value);
+        this.responseHeaders.append("Set-Cookie", serializeCookie(name, value, options));
+    }
+    delete(name, options) {
+        this.parsed.delete(name);
+        this.responseHeaders.append("Set-Cookie", serializeCookie(name, "", { ...options, maxAge: 0 }));
+    }
+}

package/dist/util/pipeline.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents a middleware function.
+ *
+ * @template T - The type of the state object.
+ * @param state - The state object to pass through the middleware.
+ * @param next - The next middleware function in the pipeline.
+ * @returns A promise that resolves after executing the middleware.
+ *
+ * @internal
+ */
+export type Middleware<STATE = any, RESULT = any> = (state: STATE, next: () => Promise<RESULT>) => Promise<RESULT>;
+/**
+ * Executes a pipeline of middlewares in a specific order.
+ *
+ * @param {STATE} state - The state object to pass through the pipeline.
+ * @param {Array<Middleware<STATE, RESULT>>} middlewares - The middlewares to execute in the pipeline.
+ * @returns {Promise<any>} A promise that resolves after executing all middlewares in the pipeline.
+ * @template STATE - The type of the state object.
+ * @template RESULT - The type of the result object.
+ *
+ * @internal
+ */
+export declare function pipeline<STATE = any, RESULT = any>(state: STATE, ...middlewares: Array<Middleware<STATE, RESULT>>): Promise<RESULT>;

package/dist/util/pipeline.js

@@ -0,0 +1,22 @@
+/**
+ * Executes a pipeline of middlewares in a specific order.
+ *
+ * @param {STATE} state - The state object to pass through the pipeline.
+ * @param {Array<Middleware<STATE, RESULT>>} middlewares - The middlewares to execute in the pipeline.
+ * @returns {Promise<any>} A promise that resolves after executing all middlewares in the pipeline.
+ * @template STATE - The type of the state object.
+ * @template RESULT - The type of the result object.
+ *
+ * @internal
+ */
+export async function pipeline(state, ...middlewares) {
+    return await execute(state, middlewares, 0);
+}
+async function execute(state, middlewares, index) {
+    const middleware = middlewares[index];
+    if (!middleware) {
+        throw new Error("Pipeline exhausted. Make sure the last middleware in the chain returns a result without calling next().");
+    }
+    const next = () => execute(state, middlewares, index + 1);
+    return await middleware(state, next);
+}

package/dist/util/string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a camelCase string to kebab-case.
+ * Handles acronyms correctly: getUserID → get-user-id
+ * @internal
+ */
+export declare function camelToKebabCase(str: string): string;

package/dist/util/string.js

@@ -0,0 +1,11 @@
+/**
+ * Converts a camelCase string to kebab-case.
+ * Handles acronyms correctly: getUserID → get-user-id
+ * @internal
+ */
+export function camelToKebabCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .toLowerCase();
+}

package/dist/util/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extracts the Promise type. When it is not a Promise, it is kept as is.
+ * @internal
+ */
+export type UnwrappedPromise<T> = T extends Promise<infer U> ? U : T;

package/dist/util/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@atom-forge/rpc",
+	"version": "0.3.2",
+	"description": "Type-safe RPC framework for TypeScript with Zod validation and middleware support",
+	"keywords": ["rpc", "typescript", "zod", "type-safe", "middleware", "api"],
+	"author": "Gergely Laborci",
+	"license": "SEE LICENSE IN LICENSE",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"repository": {
+		"url": "git://github.com/atom-forge/rpc.git"
+	},
+	"files": [
+		"dist",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "tsc"
+	},
+	"dependencies": {
+		"msgpackr": "^1.11.8"
+	},
+	"peerDependencies": {
+		"zod": ">=4.0.0"
+	},
+	"devDependencies": {
+		"typescript": "^5.0.0",
+		"@types/node": "^25.3.1",
+		"zod": "^4.3.6"
+	}
+}