vicket 0.1.1 → 1.0.0

package/dist/next.js

@@ -1,11 +1,11 @@
 // src/next.ts
 function createVicketProxy(options) {
   return async function proxy(req, context) {
-    const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "").replace(/\/+$/, "");
+    const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "https://api.vicket.app/api/v1").replace(/\/+$/, "");
     const apiKey = options?.apiKey || process.env.VICKET_API_KEY || "";
-    if (!apiUrl || !apiKey) {
+    if (!apiKey) {
       return Response.json(
-        { error: "Missing VICKET_API_URL or VICKET_API_KEY server environment variables." },
+        { error: "Missing VICKET_API_KEY server environment variable." },
         { status: 500 }
       );
     }

package/dist/nuxt.d.ts

@@ -0,0 +1,6 @@
+declare function createVicketProxy(options?: {
+    apiUrl?: string;
+    apiKey?: string;
+}): (event: any) => Promise<any>;
+
+export { createVicketProxy };

package/dist/nuxt.js

@@ -0,0 +1,66 @@
+// src/nuxt.ts
+function createVicketProxy(options) {
+  return async (event) => {
+    const h3 = await Function('return import("h3")')();
+    const { getQuery, readBody, readMultipartFormData, getMethod, createError } = h3;
+    const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "https://api.vicket.app/api/v1").replace(/\/+$/, "");
+    const apiKey = options?.apiKey || process.env.VICKET_API_KEY || "";
+    if (!apiKey) {
+      throw createError({
+        statusCode: 500,
+        statusMessage: "Missing VICKET_API_KEY environment variable."
+      });
+    }
+    const path = event.context.params?.path || "";
+    const method = getMethod(event);
+    const query = getQuery(event);
+    const queryString = new URLSearchParams(
+      Object.entries(query).reduce((acc, [k, v]) => {
+        if (v !== void 0 && v !== null) acc[k] = String(v);
+        return acc;
+      }, {})
+    ).toString();
+    const targetUrl = `${apiUrl}/public/support/${path}${queryString ? `?${queryString}` : ""}`;
+    const contentType = event.node.req.headers["content-type"] || "";
+    const isMultipart = contentType.includes("multipart/form-data");
+    let fetchOptions;
+    if (method === "GET" || method === "HEAD") {
+      fetchOptions = {
+        method,
+        headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" }
+      };
+    } else if (isMultipart) {
+      const parts = await readMultipartFormData(event);
+      const formData = new FormData();
+      if (parts) {
+        for (const part of parts) {
+          if (part.filename) {
+            const blob = new Blob([part.data], { type: part.type || "application/octet-stream" });
+            formData.append(part.name || "file", blob, part.filename);
+          } else {
+            formData.append(part.name || "field", part.data.toString("utf-8"));
+          }
+        }
+      }
+      fetchOptions = {
+        method,
+        headers: { "X-Api-Key": apiKey },
+        body: formData
+      };
+    } else {
+      const body = await readBody(event);
+      fetchOptions = {
+        method,
+        headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" },
+        body: body ? JSON.stringify(body) : void 0
+      };
+    }
+    const response = await fetch(targetUrl, fetchOptions);
+    const data = await response.json();
+    event.node.res.statusCode = response.status;
+    return data;
+  };
+}
+export {
+  createVicketProxy
+};

package/dist/server.js

@@ -1,9 +1,9 @@
 // src/server.ts
 function createServerClient(options) {
-  const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "").replace(/\/+$/, "");
+  const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "https://api.vicket.app/api/v1").replace(/\/+$/, "");
   const apiKey = options?.apiKey || process.env.VICKET_API_KEY || "";
   async function fetchInit() {
-    if (!apiUrl || !apiKey) throw new Error("Missing VICKET_API_URL or VICKET_API_KEY.");
+    if (!apiKey) throw new Error("Missing VICKET_API_KEY.");
     const res = await fetch(`${apiUrl}/public/support/init`, {
       method: "GET",
       cache: "no-store",
@@ -16,7 +16,7 @@ function createServerClient(options) {
     return payload.data;
   }
   async function fetchThread(token) {
-    if (!apiUrl || !apiKey) throw new Error("Missing VICKET_API_URL or VICKET_API_KEY.");
+    if (!apiKey) throw new Error("Missing VICKET_API_KEY.");
     const res = await fetch(
       `${apiUrl}/public/support/ticket?token=${encodeURIComponent(token)}`,
       {

package/dist/sveltekit.d.ts

@@ -0,0 +1,21 @@
+declare function createVicketProxy(options?: {
+    apiUrl?: string;
+    apiKey?: string;
+}): {
+    GET: ({ params, url }: {
+        params: {
+            path: string;
+        };
+        url: URL;
+        request: Request;
+    }) => Promise<Response>;
+    POST: ({ params, url, request }: {
+        params: {
+            path: string;
+        };
+        url: URL;
+        request: Request;
+    }) => Promise<Response>;
+};
+
+export { createVicketProxy };

package/dist/sveltekit.js

@@ -0,0 +1,54 @@
+// src/sveltekit.ts
+function createVicketProxy(options) {
+  const getConfig = () => {
+    const apiUrl = (options?.apiUrl || process.env.VICKET_API_URL || "https://api.vicket.app/api/v1").replace(/\/+$/, "");
+    const apiKey = options?.apiKey || process.env.VICKET_API_KEY || "";
+    return { apiUrl, apiKey };
+  };
+  async function handle(request, params, url) {
+    const { apiUrl, apiKey } = getConfig();
+    if (!apiKey) {
+      return Response.json(
+        { success: false, error: "Missing VICKET_API_KEY." },
+        { status: 500 }
+      );
+    }
+    const path = params.path || "";
+    const query = url.searchParams.toString();
+    const target = `${apiUrl}/public/support/${path}${query ? `?${query}` : ""}`;
+    const contentType = request.headers.get("Content-Type") || "";
+    const isFormData = contentType.includes("multipart/form-data");
+    let upstream;
+    if (request.method === "GET" || request.method === "HEAD") {
+      upstream = await fetch(target, {
+        method: request.method,
+        headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" }
+      });
+    } else if (isFormData) {
+      const formData = await request.formData();
+      upstream = await fetch(target, {
+        method: request.method,
+        headers: { "X-Api-Key": apiKey },
+        body: formData
+      });
+    } else {
+      const body = await request.text();
+      upstream = await fetch(target, {
+        method: request.method,
+        headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" },
+        body
+      });
+    }
+    const responseBody = await upstream.text();
+    return new Response(responseBody, {
+      status: upstream.status,
+      headers: { "Content-Type": upstream.headers.get("Content-Type") || "application/json" }
+    });
+  }
+  const GET = ({ params, url }) => handle(new Request(url), params, url);
+  const POST = ({ params, url, request }) => handle(request, params, url);
+  return { GET, POST };
+}
+export {
+  createVicketProxy
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vicket",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "description": "Vicket support widget SDK",
   "type": "module",
   "exports": {
@@ -15,6 +15,14 @@
     "./next": {
       "import": "./dist/next.js",
       "types": "./dist/next.d.ts"
+    },
+    "./nuxt": {
+      "import": "./dist/nuxt.js",
+      "types": "./dist/nuxt.d.ts"
+    },
+    "./sveltekit": {
+      "import": "./dist/sveltekit.js",
+      "types": "./dist/sveltekit.d.ts"
     }
   },
   "files": [
@@ -30,11 +38,15 @@
     "typescript": "^5.9.0"
   },
   "peerDependencies": {
-    "next": ">=14.0.0"
+    "next": ">=14.0.0",
+    "h3": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "next": {
       "optional": true
+    },
+    "h3": {
+      "optional": true
     }
   }
 }