@navneet_25/tempjs 2.0.0 → 3.0.0

package/packages/core/modules/blog-compose/lib/blog/compose/interpreter.tsx

@@ -0,0 +1,55 @@
+import type { ComposeBlock, ComposeDocument } from "./types";
+import { ComposeHeading, ComposeExplain, ComposeParagraph, ComposeList, ComposeQuote } from "./blocks/text-blocks";
+import {
+  ComposeCode,
+  ComposeCommand,
+  ComposeCallout,
+  ComposeDivider,
+  ComposeImage,
+} from "./blocks/media-blocks";
+
+export function ComposeBlockView({ block }: { block: ComposeBlock }) {
+  switch (block.type) {
+    case "heading":
+      return <ComposeHeading block={block} />;
+    case "explain":
+      return <ComposeExplain block={block} />;
+    case "paragraph":
+      return <ComposeParagraph block={block} />;
+    case "code":
+      return <ComposeCode block={block} />;
+    case "command":
+      return <ComposeCommand block={block} />;
+    case "callout":
+      return <ComposeCallout block={block} />;
+    case "divider":
+      return <ComposeDivider />;
+    case "list":
+      return <ComposeList block={block} />;
+    case "quote":
+      return <ComposeQuote block={block} />;
+    case "image":
+      return <ComposeImage block={block} />;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Interpreter: renders a Compose document as React components.
+ */
+export function ComposeBlogRenderer({
+  document,
+  className,
+}: {
+  document: ComposeDocument;
+  className?: string;
+}) {
+  return (
+    <article className={className ?? "compose-blog max-w-3xl"}>
+      {document.blocks.map((block, index) => (
+        <ComposeBlockView key={index} block={block} />
+      ))}
+    </article>
+  );
+}

package/packages/core/modules/blog-compose/lib/blog/compose/registry.ts

@@ -0,0 +1,276 @@
+import type {
+  ComposeBlock,
+  ComposeBlockType,
+  ComposeCalloutBlock,
+  ComposeCodeBlock,
+  ComposeCommandBlock,
+  ComposeDividerBlock,
+  ComposeExplainBlock,
+  ComposeHeadingBlock,
+  ComposeImageBlock,
+  ComposeListBlock,
+  ComposeParagraphBlock,
+  ComposeQuoteBlock,
+} from "./types";
+
+export type ComposeFieldInput = "text" | "textarea" | "select" | "toggle" | "tags";
+
+export interface ComposeFieldDef {
+  key: string;
+  label: string;
+  description?: string;
+  input: ComposeFieldInput;
+  options?: { value: string; label: string }[];
+  placeholder?: string;
+  required?: boolean;
+}
+
+export interface ComposeBlockDefinition {
+  type: ComposeBlockType;
+  label: string;
+  description: string;
+  icon: string;
+  createDefault: () => ComposeBlock;
+  fields: ComposeFieldDef[];
+}
+
+export const COMPOSE_BLOCK_REGISTRY: Record<ComposeBlockType, ComposeBlockDefinition> = {
+  heading: {
+    type: "heading",
+    label: "Heading",
+    description: "Title, section header, or subheader with style variants.",
+    icon: "H",
+    createDefault: (): ComposeHeadingBlock => ({
+      type: "heading",
+      level: "h2",
+      variant: "default",
+      text: "",
+    }),
+    fields: [
+      { key: "text", label: "Text", input: "text", required: true, placeholder: "Section heading" },
+      {
+        key: "level",
+        label: "Level",
+        input: "select",
+        options: [
+          { value: "title", label: "Page title" },
+          { value: "h2", label: "Section (H2)" },
+          { value: "h3", label: "Subsection (H3)" },
+        ],
+      },
+      {
+        key: "variant",
+        label: "Design",
+        input: "select",
+        options: [
+          { value: "default", label: "Default" },
+          { value: "accent", label: "Accent color" },
+          { value: "serif", label: "Serif display" },
+          { value: "underline-bar", label: "Underline bar" },
+        ],
+      },
+    ],
+  },
+  explain: {
+    type: "explain",
+    label: "Explanation",
+    description: "Rich text with optional highlight and underline phrases.",
+    icon: "¶",
+    createDefault: (): ComposeExplainBlock => ({
+      type: "explain",
+      text: "",
+      variant: "default",
+      highlight: [],
+      underline: [],
+    }),
+    fields: [
+      {
+        key: "text",
+        label: "Body text",
+        input: "textarea",
+        required: true,
+        placeholder: "Write your explanation…",
+      },
+      {
+        key: "variant",
+        label: "Style",
+        input: "select",
+        options: [
+          { value: "default", label: "Default" },
+          { value: "lead", label: "Lead paragraph" },
+          { value: "muted", label: "Muted" },
+        ],
+      },
+      {
+        key: "highlight",
+        label: "Highlight phrases",
+        input: "tags",
+        description: "Exact substrings in the text to highlight (comma-separated).",
+        placeholder: "important term, keyword",
+      },
+      {
+        key: "underline",
+        label: "Underline phrases",
+        input: "tags",
+        description: "Exact substrings to underline.",
+        placeholder: "term to underline",
+      },
+    ],
+  },
+  paragraph: {
+    type: "paragraph",
+    label: "Paragraph",
+    description: "Simple body paragraph.",
+    icon: "P",
+    createDefault: (): ComposeParagraphBlock => ({ type: "paragraph", text: "" }),
+    fields: [
+      { key: "text", label: "Text", input: "textarea", required: true },
+    ],
+  },
+  code: {
+    type: "code",
+    label: "Code block",
+    description: "Syntax-friendly code snippet.",
+    icon: "</>",
+    createDefault: (): ComposeCodeBlock => ({
+      type: "code",
+      code: "",
+      language: "typescript",
+      showLineNumbers: false,
+    }),
+    fields: [
+      { key: "code", label: "Code", input: "textarea", required: true },
+      {
+        key: "language",
+        label: "Language",
+        input: "select",
+        options: [
+          { value: "typescript", label: "TypeScript" },
+          { value: "javascript", label: "JavaScript" },
+          { value: "bash", label: "Bash" },
+          { value: "json", label: "JSON" },
+          { value: "text", label: "Plain text" },
+        ],
+      },
+      { key: "showLineNumbers", label: "Show line numbers", input: "toggle" },
+    ],
+  },
+  command: {
+    type: "command",
+    label: "Command",
+    description: "Terminal command with copy-friendly styling (like docsite).",
+    icon: "$",
+    createDefault: (): ComposeCommandBlock => ({
+      type: "command",
+      command: "",
+      title: "",
+      description: "",
+    }),
+    fields: [
+      { key: "command", label: "Command", input: "textarea", required: true, placeholder: "pnpm dev" },
+      { key: "title", label: "Title (optional)", input: "text" },
+      { key: "description", label: "Description (optional)", input: "textarea" },
+    ],
+  },
+  callout: {
+    type: "callout",
+    label: "Callout",
+    description: "Info, tip, or warning box.",
+    icon: "!",
+    createDefault: (): ComposeCalloutBlock => ({
+      type: "callout",
+      variant: "info",
+      title: "",
+      text: "",
+    }),
+    fields: [
+      {
+        key: "variant",
+        label: "Variant",
+        input: "select",
+        options: [
+          { value: "info", label: "Info" },
+          { value: "tip", label: "Tip" },
+          { value: "warning", label: "Warning" },
+        ],
+      },
+      { key: "title", label: "Title", input: "text" },
+      { key: "text", label: "Body", input: "textarea", required: true },
+    ],
+  },
+  divider: {
+    type: "divider",
+    label: "Divider",
+    description: "Visual separator between sections.",
+    icon: "—",
+    createDefault: (): ComposeDividerBlock => ({ type: "divider" }),
+    fields: [],
+  },
+  list: {
+    type: "list",
+    label: "List",
+    description: "Bulleted or numbered list of items.",
+    icon: "•",
+    createDefault: (): ComposeListBlock => ({
+      type: "list",
+      style: "bullet",
+      items: [],
+    }),
+    fields: [
+      {
+        key: "style",
+        label: "Style",
+        input: "select",
+        options: [
+          { value: "bullet", label: "Bulleted" },
+          { value: "number", label: "Numbered" },
+        ],
+      },
+      {
+        key: "items",
+        label: "Items",
+        input: "tags",
+        description: "One item per comma-separated entry.",
+        placeholder: "First point, Second point",
+      },
+    ],
+  },
+  quote: {
+    type: "quote",
+    label: "Quote",
+    description: "Blockquote with optional attribution.",
+    icon: "❝",
+    createDefault: (): ComposeQuoteBlock => ({
+      type: "quote",
+      text: "",
+      attribution: "",
+    }),
+    fields: [
+      { key: "text", label: "Quote text", input: "textarea", required: true },
+      { key: "attribution", label: "Attribution (optional)", input: "text", placeholder: "Author name" },
+    ],
+  },
+  image: {
+    type: "image",
+    label: "Image",
+    description: "Image with alt text and optional caption.",
+    icon: "🖼",
+    createDefault: (): ComposeImageBlock => ({
+      type: "image",
+      src: "",
+      alt: "",
+      caption: "",
+    }),
+    fields: [
+      { key: "src", label: "Image URL or path", input: "text", required: true, placeholder: "/assets/photo.jpg" },
+      { key: "alt", label: "Alt text", input: "text", required: true },
+      { key: "caption", label: "Caption (optional)", input: "text" },
+    ],
+  },
+};
+
+export const COMPOSE_BLOCK_TYPES = Object.keys(COMPOSE_BLOCK_REGISTRY) as ComposeBlockType[];
+
+export function getComposeBlockDefinition(type: ComposeBlockType): ComposeBlockDefinition {
+  return COMPOSE_BLOCK_REGISTRY[type];
+}

package/packages/core/modules/blog-compose/lib/blog/compose/types.ts

@@ -0,0 +1,128 @@
+/**
+ * Compose Blog Engine — declarative JSON document types.
+ * First engine variant: block-based composition (not WYSIWYG).
+ */
+
+export const COMPOSE_ENGINE_ID = "compose" as const;
+
+export type ComposeHeadingLevel = "title" | "h2" | "h3";
+export type ComposeHeadingVariant = "default" | "accent" | "serif" | "underline-bar";
+
+export type ComposeExplainVariant = "default" | "lead" | "muted";
+
+export type ComposeCalloutVariant = "info" | "tip" | "warning";
+
+export type ComposeListStyle = "bullet" | "number";
+
+export interface ComposeHeadingBlock {
+  type: "heading";
+  level: ComposeHeadingLevel;
+  variant: ComposeHeadingVariant;
+  text: string;
+}
+
+export interface ComposeExplainBlock {
+  type: "explain";
+  text: string;
+  variant?: ComposeExplainVariant;
+  /** Substrings in `text` rendered with highlight styling */
+  highlight?: string[];
+  /** Substrings in `text` rendered with underline styling */
+  underline?: string[];
+}
+
+export interface ComposeParagraphBlock {
+  type: "paragraph";
+  text: string;
+}
+
+export interface ComposeCodeBlock {
+  type: "code";
+  code: string;
+  language?: string;
+  showLineNumbers?: boolean;
+}
+
+export interface ComposeCommandBlock {
+  type: "command";
+  command: string;
+  title?: string;
+  description?: string;
+}
+
+export interface ComposeCalloutBlock {
+  type: "callout";
+  variant: ComposeCalloutVariant;
+  title?: string;
+  text: string;
+}
+
+export interface ComposeDividerBlock {
+  type: "divider";
+}
+
+export interface ComposeListBlock {
+  type: "list";
+  style: ComposeListStyle;
+  items: string[];
+}
+
+export interface ComposeQuoteBlock {
+  type: "quote";
+  text: string;
+  attribution?: string;
+}
+
+export interface ComposeImageBlock {
+  type: "image";
+  src: string;
+  alt: string;
+  caption?: string;
+}
+
+export type ComposeBlock =
+  | ComposeHeadingBlock
+  | ComposeExplainBlock
+  | ComposeParagraphBlock
+  | ComposeCodeBlock
+  | ComposeCommandBlock
+  | ComposeCalloutBlock
+  | ComposeDividerBlock
+  | ComposeListBlock
+  | ComposeQuoteBlock
+  | ComposeImageBlock;
+
+export type ComposeBlockType = ComposeBlock["type"];
+
+export interface ComposeDocument {
+  engine: typeof COMPOSE_ENGINE_ID;
+  version: 1;
+  blocks: ComposeBlock[];
+}
+
+export interface BlogPostMeta {
+  id: string;
+  slug: string;
+  title: string;
+  excerpt?: string | null;
+  coverImage?: string | null;
+  engine: string;
+  published: boolean;
+  publishedAt?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface BlogPostWithContent extends BlogPostMeta {
+  content: ComposeDocument;
+}
+
+export function createEmptyComposeDocument(): ComposeDocument {
+  return { engine: COMPOSE_ENGINE_ID, version: 1, blocks: [] };
+}
+
+export function isComposeDocument(value: unknown): value is ComposeDocument {
+  if (!value || typeof value !== "object") return false;
+  const doc = value as ComposeDocument;
+  return doc.engine === COMPOSE_ENGINE_ID && doc.version === 1 && Array.isArray(doc.blocks);
+}

package/packages/core/modules/blog-compose/lib/blog/register-sitemap.ts

@@ -0,0 +1,18 @@
+import { registerDynamicSitemapProvider } from "@/lib/seo/sitemap";
+import type { SitemapPathConfig } from "@/lib/seo/types";
+import { blogComposeService } from "@/lib/features/blog-compose";
+
+registerDynamicSitemapProvider(async (): Promise<SitemapPathConfig[]> => {
+  try {
+    const posts = await blogComposeService.listPublic();
+    return posts.map((post) => ({
+      path: `/blog/${post.slug}`,
+      changeFrequency: "weekly",
+      priority: 0.7,
+      lastModified: post.publishedAt ?? post.updatedAt,
+    }));
+  } catch (error) {
+    console.error("[sitemap] failed to list blog posts:", error);
+    return [];
+  }
+});

package/packages/core/modules/blog-compose/lib/controllers/BlogComposeController.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `@/lib/features/blog-compose` instead. */
+export { BlogComposeController, blogComposeController } from "@/lib/features/blog-compose";

package/packages/core/modules/blog-compose/lib/features/blog-compose/blog-compose.controller.ts

@@ -0,0 +1,78 @@
+import { NextResponse } from "next/server";
+import { blogComposeService, BlogComposeService } from "./blog-compose.service";
+
+export class BlogComposeController {
+  private service: BlogComposeService;
+
+  constructor(service: BlogComposeService = blogComposeService) {
+    this.service = service;
+  }
+
+  async listPublic(): Promise<NextResponse> {
+    try {
+      const data = await this.service.listPublic();
+      return NextResponse.json({ success: true, data }, { status: 200 });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : "Failed to fetch blog posts";
+      return NextResponse.json({ success: false, error: message }, { status: 500 });
+    }
+  }
+
+  async listAll(): Promise<NextResponse> {
+    try {
+      const data = await this.service.listAll();
+      return NextResponse.json({ success: true, data }, { status: 200 });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : "Failed to fetch blog posts";
+      return NextResponse.json({ success: false, error: message }, { status: 500 });
+    }
+  }
+
+  async create(req: Request): Promise<NextResponse> {
+    try {
+      const body = await req.json();
+      const item = await this.service.create({
+        title: body.title,
+        slug: body.slug,
+        excerpt: body.excerpt,
+        coverImage: body.coverImage,
+        content: body.content,
+        published: body.published === true,
+      });
+      return NextResponse.json({ success: true, data: item }, { status: 201 });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : "Failed to create blog post";
+      return NextResponse.json({ success: false, error: message }, { status: 400 });
+    }
+  }
+
+  async update(req: Request, params: { id: string }): Promise<NextResponse> {
+    try {
+      const body = await req.json();
+      const item = await this.service.update(params.id, {
+        title: body.title,
+        slug: body.slug,
+        excerpt: body.excerpt,
+        coverImage: body.coverImage,
+        content: body.content,
+        published: body.published,
+      });
+      return NextResponse.json({ success: true, data: item }, { status: 200 });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : "Failed to update blog post";
+      return NextResponse.json({ success: false, error: message }, { status: 400 });
+    }
+  }
+
+  async delete(params: { id: string }): Promise<NextResponse> {
+    try {
+      const item = await this.service.delete(params.id);
+      return NextResponse.json({ success: true, data: item }, { status: 200 });
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : "Failed to delete blog post";
+      return NextResponse.json({ success: false, error: message }, { status: 400 });
+    }
+  }
+}
+
+export const blogComposeController = new BlogComposeController();

package/packages/core/modules/blog-compose/lib/features/blog-compose/blog-compose.repository.ts

@@ -0,0 +1,78 @@
+import type { BlogPost, Prisma } from "@prisma/client";
+import { prisma } from "@/lib/db";
+import type { BlogPostInput, BlogPostUpdate } from "./blog-compose.types";
+
+export class BlogComposeRepository {
+  async listPublished(): Promise<BlogPost[]> {
+    return prisma.blogPost.findMany({
+      where: { published: true },
+      orderBy: [{ publishedAt: "desc" }, { createdAt: "desc" }],
+    });
+  }
+
+  async listAll(): Promise<BlogPost[]> {
+    return prisma.blogPost.findMany({
+      orderBy: [{ updatedAt: "desc" }],
+    });
+  }
+
+  async getById(id: string): Promise<BlogPost | null> {
+    return prisma.blogPost.findUnique({ where: { id } });
+  }
+
+  async getBySlug(slug: string, publishedOnly = true): Promise<BlogPost | null> {
+    return prisma.blogPost.findFirst({
+      where: publishedOnly ? { slug, published: true } : { slug },
+    });
+  }
+
+  async create(data: BlogPostInput & { slug: string }): Promise<BlogPost> {
+    const now = data.published ? new Date() : null;
+    return prisma.blogPost.create({
+      data: {
+        title: data.title,
+        slug: data.slug,
+        excerpt: data.excerpt,
+        coverImage: data.coverImage,
+        engine: data.engine ?? "compose",
+        contentJson: data.content as unknown as Prisma.InputJsonValue,
+        published: data.published ?? false,
+        publishedAt: now,
+      },
+    });
+  }
+
+  async update(id: string, data: BlogPostUpdate & { slug?: string }): Promise<BlogPost> {
+    const existing = await this.getById(id);
+    if (!existing) throw new Error("Blog post not found.");
+
+    let publishedAt = existing.publishedAt;
+    if (data.published === true && !existing.published) {
+      publishedAt = new Date();
+    }
+    if (data.published === false) {
+      publishedAt = null;
+    }
+
+    const patch: Prisma.BlogPostUpdateInput = {
+      title: data.title,
+      slug: data.slug,
+      excerpt: data.excerpt,
+      coverImage: data.coverImage,
+      published: data.published,
+      publishedAt,
+    };
+
+    if (data.content) {
+      patch.contentJson = data.content as unknown as Prisma.InputJsonValue;
+    }
+
+    return prisma.blogPost.update({ where: { id }, data: patch });
+  }
+
+  async delete(id: string): Promise<BlogPost> {
+    return prisma.blogPost.delete({ where: { id } });
+  }
+}
+
+export const blogComposeRepository = new BlogComposeRepository();