vicket 0.1.0 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+type TemplateOption = {
+    id: string;
+    label: string;
+    value: string;
+};
+type TemplateQuestion = {
+    id: string;
+    label: string;
+    type: "TEXT" | "TEXTAREA" | "SELECT" | "CHECKBOX" | "DATE" | "FILE";
+    required: boolean;
+    order: number;
+    options?: TemplateOption[];
+};
+type Template = {
+    id: string;
+    name: string;
+    description: string;
+    questions: TemplateQuestion[];
+};
+type Article = {
+    id: string;
+    title: string;
+    slug: string;
+    content: string;
+};
+type Faq = {
+    id: string;
+    question: string;
+    answer: string;
+};
+type SupportInitResponse = {
+    success: boolean;
+    data?: {
+        website?: {
+            name?: string;
+        };
+        templates: Template[];
+        articles?: Article[];
+        faqs?: Faq[];
+    };
+    error?: string;
+};
+type FormValues = {
+    email: string;
+    title: string;
+    answers: Record<string, unknown>;
+};
+type Attachment = {
+    id: string;
+    original_filename: string;
+    url: string;
+};
+type Message = {
+    id: string;
+    content: string;
+    author_type: "reporter" | "user" | "system";
+    created_at: string;
+    attachments?: Attachment[];
+};
+type TicketAnswer = {
+    id: string;
+    question_label: string;
+    answer: string;
+    attachments?: Attachment[];
+};
+type TicketThread = {
+    id: string;
+    title: string;
+    status?: {
+        label: string;
+    };
+    priority?: {
+        label: string;
+    };
+    messages: Message[];
+    answers?: TicketAnswer[];
+};
+declare const AUTHOR_LABELS: Record<string, string>;
+declare const initialFormValues: FormValues;
+declare function cn(...classes: (string | boolean | undefined | null)[]): string;
+declare function stripHtml(html: string): string;
+declare function sanitizeHtml(html: string): string;
+declare function formatDate(iso: string): string;
+declare function isFileAnswer(answer: string): boolean;
+declare function formatAnswerText(value: string): string;
+declare function fetchInit(): Promise<NonNullable<SupportInitResponse["data"]>>;
+declare function createTicket(body: {
+    email: string;
+    title: string;
+    templateId: string;
+    answers: Record<string, unknown>;
+    hasFiles: boolean;
+    fileQuestionIds: string[];
+}): Promise<{
+    emailLimitReached?: boolean;
+    warning?: string;
+}>;
+declare function fetchThread(token: string): Promise<TicketThread>;
+declare function sendReply(token: string, content: string, files: File[]): Promise<void>;
+
+export { AUTHOR_LABELS, type Article, type Attachment, type Faq, type FormValues, type Message, type SupportInitResponse, type Template, type TemplateOption, type TemplateQuestion, type TicketAnswer, type TicketThread, cn, createTicket, fetchInit, fetchThread, formatAnswerText, formatDate, initialFormValues, isFileAnswer, sanitizeHtml, sendReply, stripHtml };

package/dist/index.js

@@ -0,0 +1,141 @@
+// src/index.ts
+var PROXY_BASE = "/api/vicket";
+var AUTHOR_LABELS = {
+  reporter: "You",
+  user: "Support",
+  system: "System"
+};
+var initialFormValues = { email: "", title: "", answers: {} };
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "");
+}
+function sanitizeHtml(html) {
+  return html.replace(/<script[\s>][\s\S]*?<\/script>/gi, "").replace(/<iframe[\s>][\s\S]*?<\/iframe>/gi, "").replace(/on\w+\s*=\s*"[^"]*"/gi, "").replace(/on\w+\s*=\s*'[^']*'/gi, "").replace(/on\w+\s*=\s*[^\s>]*/gi, "").replace(/javascript\s*:/gi, "");
+}
+function formatDate(iso) {
+  try {
+    return new Intl.DateTimeFormat("en", {
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    }).format(new Date(iso));
+  } catch {
+    return iso;
+  }
+}
+function isFileAnswer(answer) {
+  return answer?.includes("__isFile:true") || answer?.includes("map[__isFile");
+}
+function formatAnswerText(value) {
+  if (!value) return "";
+  const trimmed = value.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    const rawItems = trimmed.slice(1, -1).trim();
+    return rawItems.length > 0 ? rawItems.split(/\s+/).join(", ") : "";
+  }
+  return value;
+}
+async function fetchInit() {
+  const response = await fetch(`${PROXY_BASE}/init`, {
+    method: "GET",
+    cache: "no-store",
+    headers: { "Content-Type": "application/json" }
+  });
+  const payload = await response.json();
+  if (!response.ok || !payload?.success || !payload?.data) {
+    throw new Error(payload?.error || "Failed to load support data.");
+  }
+  return payload.data;
+}
+async function createTicket(body) {
+  const payload = {
+    email: body.email,
+    title: body.title,
+    templateId: body.templateId,
+    answers: { ...body.answers }
+  };
+  let response;
+  if (body.hasFiles) {
+    const formData = new FormData();
+    const normalizedAnswers = {};
+    for (const [questionId, answer] of Object.entries(payload.answers)) {
+      if (answer instanceof File) {
+        formData.append(`files[${questionId}]`, answer);
+        normalizedAnswers[questionId] = "__isFile:true";
+      } else {
+        normalizedAnswers[questionId] = answer;
+      }
+    }
+    formData.append("data", JSON.stringify({ ...payload, answers: normalizedAnswers }));
+    response = await fetch(`${PROXY_BASE}/tickets`, { method: "POST", body: formData });
+  } else {
+    response = await fetch(`${PROXY_BASE}/tickets`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+  const responsePayload = await response.json();
+  if (!response.ok || !responsePayload?.success) {
+    throw new Error(responsePayload?.error || "Failed to create ticket.");
+  }
+  return {
+    emailLimitReached: responsePayload.data?.email_limit_reached ?? false,
+    warning: responsePayload.data?.warning
+  };
+}
+async function fetchThread(token) {
+  const response = await fetch(
+    `${PROXY_BASE}/ticket?token=${encodeURIComponent(token)}`,
+    { method: "GET", cache: "no-store", headers: { "Content-Type": "application/json" } }
+  );
+  const payload = await response.json();
+  if (!response.ok || !payload?.success || !payload?.data) {
+    if (payload?.error_code === "ticket-link-expired") {
+      throw new Error("This link has expired. A new secure link has been sent to your email.");
+    }
+    throw new Error(payload?.error || "Failed to load ticket.");
+  }
+  return payload.data;
+}
+async function sendReply(token, content, files) {
+  const url = `${PROXY_BASE}/ticket/messages?token=${encodeURIComponent(token)}`;
+  let response;
+  if (files.length > 0) {
+    const formData = new FormData();
+    formData.append("data", JSON.stringify({ content }));
+    for (const file of files) formData.append("files", file);
+    response = await fetch(url, { method: "POST", body: formData });
+  } else {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content })
+    });
+  }
+  const payload = await response.json();
+  if (!response.ok || !payload?.success) {
+    if (payload?.error_code === "ticket-link-expired") {
+      throw new Error("This link has expired. A new secure link has been sent to your email.");
+    }
+    throw new Error(payload?.error || "Failed to send reply.");
+  }
+}
+export {
+  AUTHOR_LABELS,
+  cn,
+  createTicket,
+  fetchInit,
+  fetchThread,
+  formatAnswerText,
+  formatDate,
+  initialFormValues,
+  isFileAnswer,
+  sanitizeHtml,
+  sendReply,
+  stripHtml
+};

package/dist/next.d.ts

@@ -0,0 +1,10 @@
+declare function createVicketProxy(options?: {
+    apiUrl?: string;
+    apiKey?: string;
+}): (req: Request, context: {
+    params: Promise<{
+        path: string[];
+    }>;
+}) => Promise<Response>;
+
+export { createVicketProxy };

package/dist/next.js

@@ -0,0 +1,39 @@
+// src/next.ts
+function createVicketProxy(options) {
+  return async function proxy(req, context) {
+    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) {
+      return Response.json(
+        { error: "Missing VICKET_API_KEY server environment variable." },
+        { status: 500 }
+      );
+    }
+    const { path } = await context.params;
+    const subpath = path.join("/");
+    const url = new URL(`${apiUrl}/public/support/${subpath}`);
+    const reqUrl = new URL(req.url);
+    reqUrl.searchParams.forEach((value, key) => url.searchParams.set(key, value));
+    const headers = { "X-Api-Key": apiKey };
+    const contentType = req.headers.get("content-type") || "";
+    let body = null;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      if (contentType.includes("multipart/form-data")) {
+        body = await req.blob();
+        headers["Content-Type"] = contentType;
+      } else {
+        body = await req.text();
+        headers["Content-Type"] = contentType || "application/json";
+      }
+    }
+    const upstream = await fetch(url.toString(), { method: req.method, headers, body });
+    const responseBody = await upstream.arrayBuffer();
+    return new Response(responseBody, {
+      status: upstream.status,
+      headers: { "Content-Type": upstream.headers.get("Content-Type") || "application/json" }
+    });
+  };
+}
+export {
+  createVicketProxy
+};

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.d.ts

@@ -0,0 +1,11 @@
+import { SupportInitResponse, TicketThread } from './index.js';
+
+declare function createServerClient(options?: {
+    apiUrl?: string;
+    apiKey?: string;
+}): {
+    fetchInit: () => Promise<NonNullable<SupportInitResponse["data"]>>;
+    fetchThread: (token: string) => Promise<TicketThread>;
+};
+
+export { createServerClient };

package/dist/server.js

@@ -0,0 +1,41 @@
+// src/server.ts
+function createServerClient(options) {
+  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 (!apiKey) throw new Error("Missing VICKET_API_KEY.");
+    const res = await fetch(`${apiUrl}/public/support/init`, {
+      method: "GET",
+      cache: "no-store",
+      headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" }
+    });
+    const payload = await res.json();
+    if (!res.ok || !payload?.success || !payload?.data) {
+      throw new Error(payload?.error || "Failed to load support data.");
+    }
+    return payload.data;
+  }
+  async function fetchThread(token) {
+    if (!apiKey) throw new Error("Missing VICKET_API_KEY.");
+    const res = await fetch(
+      `${apiUrl}/public/support/ticket?token=${encodeURIComponent(token)}`,
+      {
+        method: "GET",
+        cache: "no-store",
+        headers: { "X-Api-Key": apiKey, "Content-Type": "application/json" }
+      }
+    );
+    const payload = await res.json();
+    if (!res.ok || !payload?.success || !payload?.data) {
+      if (payload?.error_code === "ticket-link-expired") {
+        throw new Error("This link has expired. A new secure link has been sent to your email.");
+      }
+      throw new Error(payload?.error || "Failed to load ticket.");
+    }
+    return payload.data;
+  }
+  return { fetchInit, fetchThread };
+}
+export {
+  createServerClient
+};

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.0",
+  "version": "1.0.0",
   "description": "Vicket support widget SDK",
   "type": "module",
   "exports": {
@@ -15,23 +15,38 @@
     "./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": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch"
   },
   "devDependencies": {
+    "@types/node": "^22.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.9.0"
   },
   "peerDependencies": {
-    "next": ">=14.0.0"
+    "next": ">=14.0.0",
+    "h3": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "next": {
       "optional": true
+    },
+    "h3": {
+      "optional": true
     }
   }
 }