pasika 0.10.2 → 0.10.3

package/dist/helpers/cn.d.ts

@@ -0,0 +1,10 @@
+import { ClassValue } from 'clsx';
+
+/**
+ * Combines conditional classes and resolves conflicting Tailwind utilities, so a
+ * later class wins within one utility group and the same variant, and a wider
+ * class later in the list replaces the narrower ones it covers.
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+export { cn };

package/dist/helpers/cn.js

@@ -0,0 +1,9 @@
+// helpers/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+export {
+  cn
+};

package/dist/helpers/http-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The failure a route answers with: the status the response carries, the message
+ * a client reads, and what a failed upstream call answered with, so a module that
+ * knows that upstream can name the reason and a log line can keep the body.
+ */
+declare class HttpError extends Error {
+    readonly status: number;
+    readonly data: unknown;
+    constructor(message: string, status: number, data?: unknown);
+}
+
+export { HttpError };

package/dist/helpers/http-error.js

@@ -0,0 +1,6 @@
+import {
+  HttpError
+} from "../chunk-7JI2V3HF.js";
+export {
+  HttpError
+};

package/dist/helpers/with-response.d.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+
+/** Whatever a handler's own response needs to carry; a failure never inherits it. */
+type ResponseHeaders = Headers | Record<string, string>;
+type HandlerResult<TData> = {
+    message: string;
+    data: TData;
+    status?: number;
+    headers?: ResponseHeaders;
+} | {
+    body: ReadableStream<Uint8Array>;
+    status: number;
+    headers?: ResponseHeaders;
+};
+/**
+ * Turns a handler's result, or a failure thrown under it, into a response: the data
+ * goes through the response schema, an `HttpError` becomes `{ data: null, message }`
+ * at its own status and is never cached, and anything else stays an error.
+ *
+ * A handler whose own response is not JSON calls it with the handler alone and returns
+ * `{ body, status, headers }`, so a relayed body passes through unread.
+ */
+declare function withResponse<TSchema extends z.ZodType, Args extends unknown[]>(responseSchema: TSchema, handler?: (...args: Args) => Promise<HandlerResult<z.input<TSchema>>>): (...args: Args) => Promise<NextResponse>;
+declare function withResponse<Args extends unknown[]>(handler: (...args: Args) => Promise<HandlerResult<ReadableStream<Uint8Array>>>): (...args: Args) => Promise<NextResponse>;
+
+export { type HandlerResult, type ResponseHeaders, withResponse };

package/dist/helpers/with-response.js

@@ -0,0 +1,36 @@
+import {
+  HttpError
+} from "../chunk-7JI2V3HF.js";
+
+// helpers/with-response.ts
+import { NextResponse } from "next/server";
+import { z } from "zod";
+var streamBody = z.custom((value) => value instanceof ReadableStream);
+function missingHandler() {
+  throw new HttpError("withResponse requires a response schema and a handler.", 500);
+}
+function withResponse(responseSchemaOrHandler, handler) {
+  const respond = (schema, wrapped = missingHandler) => async (...requestArgs) => {
+    try {
+      const result = await wrapped(...requestArgs);
+      if ("body" in result) {
+        const { body, status: status2, headers: headers2 } = result;
+        return new NextResponse(streamBody.parse(body), { status: status2, headers: headers2 });
+      }
+      const { message, data, status, headers } = result;
+      return NextResponse.json({ data: schema.parse(data), message }, { status, headers });
+    } catch (error) {
+      if (error instanceof HttpError) {
+        return NextResponse.json(
+          { data: null, message: error.message },
+          { status: error.status, headers: { "Cache-Control": "no-store" } }
+        );
+      }
+      throw error;
+    }
+  };
+  return typeof responseSchemaOrHandler === "function" ? respond(streamBody, responseSchemaOrHandler) : respond(responseSchemaOrHandler, handler);
+}
+export {
+  withResponse
+};

package/dist/helpers/zod-fetch.d.ts

@@ -0,0 +1,25 @@
+import { ZodType, z } from 'zod';
+
+interface ZodFetchOptions<TSchema extends ZodType = never> {
+    url: string | URL;
+    init?: RequestInit;
+    responseSchema?: TSchema;
+}
+/** The response itself, for a caller whose own response relays a body nothing has read. */
+interface ZodFetchRelayedResponse {
+    body: ReadableStream<Uint8Array>;
+    status: number;
+    headers: Headers;
+}
+/**
+ * The only module in a repository that calls `fetch`. It hands a JSON body back as
+ * data the response schema accepted, and a failure back as an `HttpError` carrying
+ * the status the upstream reported, the message for a client, and what the upstream
+ * answered with. A call that names no response schema gets the response itself.
+ */
+declare function zodFetch<TSchema extends ZodType>(options: ZodFetchOptions<TSchema> & {
+    responseSchema: TSchema;
+}): Promise<z.output<TSchema>>;
+declare function zodFetch(options: ZodFetchOptions): Promise<ZodFetchRelayedResponse>;
+
+export { type ZodFetchOptions, type ZodFetchRelayedResponse, zodFetch };

package/dist/helpers/zod-fetch.js

@@ -0,0 +1,43 @@
+import {
+  HttpError
+} from "../chunk-7JI2V3HF.js";
+
+// helpers/zod-fetch.ts
+import { z } from "zod";
+var streamBody = z.custom((value) => value instanceof ReadableStream);
+function decodeFailureBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return parsed;
+  } catch {
+    return body;
+  }
+}
+async function zodFetch(options) {
+  const response = await fetch(options.url, options.init);
+  if (!response.ok) {
+    const body2 = await response.text();
+    const statusText = response.statusText === "" ? "" : ` ${response.statusText}`;
+    throw new HttpError(
+      `Request failed with status ${String(response.status)}${statusText}`,
+      response.status,
+      decodeFailureBody(body2)
+    );
+  }
+  if (options.responseSchema === void 0) {
+    const streamed = streamBody.safeParse(response.body);
+    if (!streamed.success) {
+      throw new HttpError("The upstream answered without a body to relay.", response.status);
+    }
+    return { body: streamed.data, status: response.status, headers: response.headers };
+  }
+  const body = await response.text();
+  if (body === "") {
+    throw new HttpError("The upstream answered without a body to decode.", response.status);
+  }
+  const decoded = JSON.parse(body);
+  return options.responseSchema.parse(decoded);
+}
+export {
+  zodFetch
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",
@@ -12,6 +12,22 @@
     "./eslint": {
       "types": "./dist/eslint/pasika/index.d.ts",
       "import": "./dist/eslint/pasika/index.js"
+    },
+    "./cn": {
+      "types": "./dist/helpers/cn.d.ts",
+      "import": "./dist/helpers/cn.js"
+    },
+    "./http-error": {
+      "types": "./dist/helpers/http-error.d.ts",
+      "import": "./dist/helpers/http-error.js"
+    },
+    "./zod-fetch": {
+      "types": "./dist/helpers/zod-fetch.d.ts",
+      "import": "./dist/helpers/zod-fetch.js"
+    },
+    "./with-response": {
+      "types": "./dist/helpers/with-response.d.ts",
+      "import": "./dist/helpers/with-response.js"
     }
   },
   "files": [
@@ -54,10 +70,13 @@
     "@types/mdast": "4.0.4",
     "@types/node": "26.4.0",
     "@vitest/coverage-v8": "5.0.0",
+    "clsx": "2.1.1",
     "eslint": "10.9.1",
     "husky": "9.1.7",
     "lint-staged": "17.4.1",
+    "next": "16.3.5",
     "prettier": "3.8.1",
+    "tailwind-merge": "3.7.0",
     "tsup": "8.5.1",
     "tsx": "4.23.12",
     "typescript": "6.0.3",
@@ -68,7 +87,25 @@
   "peerDependencies": {
     "@eslint/css": ">=1.4.0",
     "@eslint/json": ">=2.0.1",
-    "@eslint/markdown": ">=8.0.3"
+    "@eslint/markdown": ">=8.0.3",
+    "clsx": ">=2.0.0",
+    "next": ">=15.0.0",
+    "tailwind-merge": ">=3.0.0",
+    "zod": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "clsx": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "tailwind-merge": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=22"