tetrons 2.3.26 → 2.3.28

package/dist/app/api/ai-action/route.d.mts

@@ -0,0 +1,9 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+declare function POST(req: NextRequest): Promise<NextResponse<{
+    error: any;
+}> | NextResponse<{
+    response: any;
+}>>;
+
+export { POST };

package/dist/app/api/ai-action/route.mjs

@@ -0,0 +1,36 @@
+// src/app/api/ai-action/route.ts
+import { NextResponse } from "next/server";
+async function POST(req) {
+  try {
+    const { content } = await req.json();
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "gpt-4",
+        messages: [{ role: "user", content }],
+        temperature: 0.7
+      })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return NextResponse.json({ error: data.error.message }, { status: 500 });
+    }
+    return NextResponse.json({ response: data.choices[0].message.content });
+  } catch (error) {
+    console.error("AI generation error:", error);
+    if (error instanceof Error) {
+      return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+    return NextResponse.json(
+      { error: "Unknown error occurred." },
+      { status: 500 }
+    );
+  }
+}
+export {
+  POST
+};

package/dist/app/api/export/route.d.mts

@@ -0,0 +1,3 @@
+declare function GET(req: Request): Response;
+
+export { GET };

package/dist/app/api/export/route.mjs

@@ -0,0 +1,8 @@
+// src/app/api/export/route.ts
+function GET(req) {
+  console.log(req.method);
+  return new Response("Hello, world!", { status: 200 });
+}
+export {
+  GET
+};

package/dist/app/api/register/route.d.mts

@@ -0,0 +1,10 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+declare function POST(req: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    apiKey: string;
+    expiresAt: Date | null;
+}>>;
+
+export { POST };

package/dist/app/api/register/route.mjs

@@ -0,0 +1,85 @@
+// src/app/api/register/route.ts
+import { NextResponse } from "next/server";
+
+// src/lib/db.js
+import mongoose from "mongoose";
+var MONGO_URL = process.env.MONGO_URL;
+var connectDB = async () => {
+  if (mongoose.connection.readyState >= 1) {
+    return;
+  }
+  try {
+    await mongoose.connect(MONGO_URL);
+    console.log("Connected to MongoDB \u{1F44D}");
+  } catch (error) {
+    console.error("MongoDB connection failed \u274C", error);
+    process.exit(1);
+  }
+};
+
+// src/models/ApiKey.ts
+import mongoose2 from "mongoose";
+var ApiKeySchema = new mongoose2.Schema({
+  email: { type: String, required: true },
+  organization: { type: String, required: true },
+  version: {
+    type: String,
+    enum: ["free", "pro", "premium", "platinum"],
+    required: true
+  },
+  apiKey: { type: String, required: true, unique: true },
+  createdAt: { type: Date, default: Date.now },
+  expiresAt: { type: Date }
+});
+var ApiKey = mongoose2.models.ApiKey || mongoose2.model("ApiKey", ApiKeySchema);
+
+// src/utils/apiKeyUtils.ts
+import crypto from "crypto";
+var FREE_API_KEY = process.env.TETRONS_FREE_KEY || "TETRONS_FREE_KEY";
+var SECRET_KEY = process.env.API_KEY_SECRET || "default-secret-key";
+function getFreeApiKey() {
+  return FREE_API_KEY;
+}
+var VERSION_PREFIXES = {
+  pro: "PRO",
+  premium: "PREMIUM",
+  platinum: "PLATINUM"
+};
+function generateUserApiKey(email, organization, version) {
+  const input = `${email.trim().toLowerCase()}:${organization.trim().toLowerCase()}`;
+  const hash = crypto.createHmac("sha256", SECRET_KEY).update(input).digest("hex").toUpperCase();
+  const prefix = VERSION_PREFIXES[version];
+  return `${prefix}${hash.slice(0, 48 - prefix.length)}`;
+}
+
+// src/app/api/register/route.ts
+async function POST(req) {
+  const body = await req.json();
+  const { email, organization, version } = body;
+  if (!email || !organization || !version) {
+    return NextResponse.json({ error: "Missing fields" }, { status: 400 });
+  }
+  await connectDB();
+  const lowerEmail = email.trim().toLowerCase();
+  const lowerOrg = organization.trim().toLowerCase();
+  await ApiKey.deleteMany({ email: lowerEmail, version });
+  let apiKey;
+  let expiresAt = null;
+  if (version === "free") {
+    apiKey = getFreeApiKey();
+    expiresAt = new Date(Date.now() + 14 * 24 * 60 * 60 * 1e3);
+  } else {
+    apiKey = generateUserApiKey(lowerEmail, lowerOrg, version);
+  }
+  await ApiKey.create({
+    email: lowerEmail,
+    organization: lowerOrg,
+    version,
+    apiKey,
+    expiresAt
+  });
+  return NextResponse.json({ apiKey, expiresAt });
+}
+export {
+  POST
+};

package/dist/app/api/save/route.d.mts

@@ -0,0 +1,9 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+declare function POST(request: NextRequest): Promise<NextResponse<{
+    message: string;
+}> | NextResponse<{
+    error: string;
+}>>;
+
+export { POST };

package/dist/app/api/save/route.mjs

@@ -0,0 +1,18 @@
+// src/app/api/save/route.ts
+import { NextResponse } from "next/server";
+import path from "path";
+import fs from "fs/promises";
+async function POST(request) {
+  try {
+    const json = await request.json();
+    const publicDir = path.join(process.cwd(), "public");
+    const filePath = path.join(publicDir, "editor-content.json");
+    await fs.writeFile(filePath, JSON.stringify(json, null, 2), "utf-8");
+    return NextResponse.json({ message: "File saved successfully" });
+  } catch {
+    return NextResponse.json({ error: "Failed to save file" }, { status: 500 });
+  }
+}
+export {
+  POST
+};

package/dist/app/api/transcribe/route.d.mts

@@ -0,0 +1,10 @@
+import { NextResponse } from 'next/server';
+
+declare const runtime = "edge";
+declare function POST(req: Request): Promise<NextResponse<{
+    error: any;
+}> | NextResponse<{
+    transcript: any;
+}>>;
+
+export { POST, runtime };

package/dist/app/api/transcribe/route.mjs

@@ -0,0 +1,46 @@
+// src/app/api/transcribe/route.ts
+import { NextResponse } from "next/server";
+var runtime = "edge";
+async function POST(req) {
+  try {
+    const formData = await req.formData();
+    const file = formData.get("file");
+    if (!file) {
+      return NextResponse.json({ error: "No file uploaded" }, { status: 400 });
+    }
+    const arrayBuffer = await file.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const whisperFormData = new FormData();
+    whisperFormData.append(
+      "file",
+      new Blob([buffer], { type: file.type || "audio/webm" }),
+      "voice.webm"
+    );
+    whisperFormData.append("model", "whisper-1");
+    const whisperRes = await fetch(
+      "https://api.openai.com/v1/audio/transcriptions",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${process.env.OPENAI_API_KEY ?? ""}`
+        },
+        body: whisperFormData
+      }
+    );
+    const result = await whisperRes.json();
+    if (!whisperRes.ok) {
+      return NextResponse.json(
+        { error: result?.error?.message || "Transcription failed" },
+        { status: 500 }
+      );
+    }
+    return NextResponse.json({ transcript: result.text });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown server error";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+export {
+  POST,
+  runtime
+};

package/dist/app/api/validate/route.d.mts

@@ -0,0 +1,13 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+declare function OPTIONS(): Promise<Response>;
+declare function POST(req: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    valid: boolean;
+    version: any;
+    email: any;
+    organization: any;
+}>>;
+
+export { OPTIONS, POST };

package/dist/app/api/validate/route.mjs

@@ -0,0 +1,107 @@
+// src/app/api/validate/route.ts
+import { NextResponse } from "next/server";
+
+// src/lib/db.js
+import mongoose from "mongoose";
+var MONGO_URL = process.env.MONGO_URL;
+var connectDB = async () => {
+  if (mongoose.connection.readyState >= 1) {
+    return;
+  }
+  try {
+    await mongoose.connect(MONGO_URL);
+    console.log("Connected to MongoDB \u{1F44D}");
+  } catch (error) {
+    console.error("MongoDB connection failed \u274C", error);
+    process.exit(1);
+  }
+};
+
+// src/models/ApiKey.ts
+import mongoose2 from "mongoose";
+var ApiKeySchema = new mongoose2.Schema({
+  email: { type: String, required: true },
+  organization: { type: String, required: true },
+  version: {
+    type: String,
+    enum: ["free", "pro", "premium", "platinum"],
+    required: true
+  },
+  apiKey: { type: String, required: true, unique: true },
+  createdAt: { type: Date, default: Date.now },
+  expiresAt: { type: Date }
+});
+var ApiKey = mongoose2.models.ApiKey || mongoose2.model("ApiKey", ApiKeySchema);
+
+// src/app/api/validate/route.ts
+var corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+async function OPTIONS() {
+  return new Response(null, {
+    status: 204,
+    headers: corsHeaders
+  });
+}
+async function POST(req) {
+  try {
+    const body = await req.json();
+    const apiKey = body.apiKey;
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: "API key required" },
+        {
+          status: 400,
+          headers: corsHeaders
+        }
+      );
+    }
+    await connectDB();
+    const keyEntry = await ApiKey.findOne({ apiKey });
+    if (!keyEntry) {
+      return NextResponse.json(
+        { error: "Invalid API key" },
+        {
+          status: 401,
+          headers: corsHeaders
+        }
+      );
+    }
+    if (keyEntry.version === "free" && keyEntry.expiresAt && /* @__PURE__ */ new Date() > new Date(keyEntry.expiresAt)) {
+      return NextResponse.json(
+        { error: "Free trial expired" },
+        {
+          status: 403,
+          headers: corsHeaders
+        }
+      );
+    }
+    return NextResponse.json(
+      {
+        valid: true,
+        version: keyEntry.version,
+        email: keyEntry.email,
+        organization: keyEntry.organization
+      },
+      {
+        status: 200,
+        headers: corsHeaders
+      }
+    );
+  } catch (err) {
+    console.error("Validation Error:", err);
+    return NextResponse.json(
+      { error: "Server error" },
+      {
+        status: 500,
+        headers: corsHeaders
+      }
+    );
+  }
+}
+export {
+  OPTIONS,
+  POST
+};

package/dist/components/tetrons/ResizableImageComponent.tsx

@@ -1,15 +1,7 @@
-import React, { useRef, useEffect } from "react";
-import { NodeViewWrapper, NodeViewRendererProps } from "@tiptap/react";
+import React, { useRef, useEffect, useState } from "react";
+import { NodeViewWrapper, ReactNodeViewProps } from "@tiptap/react";
 
-interface ResizableImageProps extends NodeViewRendererProps {
-  updateAttributes: (attrs: {
-    width?: number | null;
-    height?: number | null;
-  }) => void;
-  selected?: boolean;
-}
-
-const ResizableImageComponent: React.FC<ResizableImageProps> = ({
+const ResizableImageComponent: React.FC<ReactNodeViewProps> = ({
   node,
   updateAttributes,
   selected,
@@ -21,22 +13,44 @@ const ResizableImageComponent: React.FC<ResizableImageProps> = ({
     width?: number | null;
     height?: number | null;
   };
+
+  const defaultWidth = width ?? 300;
+  const defaultHeight = height ?? 200;
+  const aspectRatio = defaultHeight > 0 ? defaultWidth / defaultHeight : 4 / 3;
+
   const wrapperRef = useRef<HTMLDivElement>(null);
-  const imgRef = useRef<HTMLImageElement>(null);
+  const [isResizing, setIsResizing] = useState(false);
 
   useEffect(() => {
-    const img = imgRef.current;
-    if (!img) return;
+    const handleMouseMove = (e: MouseEvent) => {
+      if (!isResizing || !wrapperRef.current) return;
+
+      const rect = wrapperRef.current.getBoundingClientRect();
+      const newWidth = e.clientX - rect.left;
+      const newHeight = newWidth / aspectRatio;
+
+      if (newWidth > 50 && newHeight > 50) {
+        updateAttributes({
+          width: Math.round(newWidth),
+          height: Math.round(newHeight),
+        });
+      }
+    };
+
+    const handleMouseUp = () => {
+      setIsResizing(false);
+    };
 
-    const observer = new ResizeObserver(() => {
-      const w = Math.round(img.offsetWidth);
-      const h = Math.round(img.offsetHeight);
-      updateAttributes({ width: w, height: h });
-    });
+    if (isResizing) {
+      window.addEventListener("mousemove", handleMouseMove);
+      window.addEventListener("mouseup", handleMouseUp);
+    }
 
-    observer.observe(img);
-    return () => observer.disconnect();
-  }, [updateAttributes]);
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+      window.removeEventListener("mouseup", handleMouseUp);
+    };
+  }, [isResizing, updateAttributes, aspectRatio]);
 
   return (
     <NodeViewWrapper
@@ -46,30 +60,51 @@ const ResizableImageComponent: React.FC<ResizableImageProps> = ({
         selected ? "ProseMirror-selectednode" : ""
       }`}
       style={{
-        resize: "both",
-        overflow: "auto",
+        position: "relative",
         border: "1px solid #ccc",
-        padding: 2,
         display: "inline-block",
+        width: `${defaultWidth}px`,
+        height: `${defaultHeight}px`,
+        minWidth: "50px",
+        minHeight: "50px",
         maxWidth: "100%",
+        userSelect: "none",
+        padding: 2,
       }}
     >
-      {/* eslint-disable-next-line @next/next/no-img-element */}
       <img
-        ref={imgRef}
         src={src}
         alt={alt ?? ""}
         title={title ?? ""}
         loading="lazy"
         style={{
-          width: width ? `${width}px` : "auto",
-          height: height ? `${height}px` : "auto",
+          width: "100%",
+          height: "100%",
+          objectFit: "contain",
           display: "block",
           userSelect: "none",
           pointerEvents: "auto",
         }}
         draggable={false}
       />
+
+      <div
+        onMouseDown={(e) => {
+          e.preventDefault();
+          setIsResizing(true);
+        }}
+        style={{
+          position: "absolute",
+          width: "12px",
+          height: "12px",
+          right: 2,
+          bottom: 2,
+          background: "#ccc",
+          borderRadius: "2px",
+          cursor: "nwse-resize",
+          zIndex: 10,
+        }}
+      />
     </NodeViewWrapper>
   );
 };