@bivabdas/sharq 1.0.0

package/lib/renderer.js

@@ -0,0 +1,298 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+function escapeHtml(value) {
+  return String(value).replace(/[&<>"']/g, (char) => {
+    const map = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      "\"": "&quot;",
+      "'": "&#39;"
+    };
+
+    return map[char];
+  });
+}
+
+function sanitizeHref(href) {
+  const normalizedHref = href.trim();
+  const loweredHref = normalizedHref.toLowerCase();
+
+  if (
+    loweredHref.startsWith("javascript:") ||
+    loweredHref.startsWith("data:") ||
+    loweredHref.startsWith("vbscript:")
+  ) {
+    return "#";
+  }
+
+  return normalizedHref;
+}
+
+function parseFrontmatter(markdown) {
+  if (!markdown.startsWith("---")) {
+    throw new Error("Missing frontmatter block.");
+  }
+
+  const match = markdown.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+
+  if (!match) {
+    throw new Error("Invalid frontmatter format.");
+  }
+
+  const [, rawFrontmatter, content] = match;
+  const data = {};
+
+  for (const line of rawFrontmatter.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+
+    const separatorIndex = line.indexOf(":");
+
+    if (separatorIndex === -1) {
+      throw new Error(`Invalid frontmatter line: ${line}`);
+    }
+
+    const key = line.slice(0, separatorIndex).trim();
+    const value = line.slice(separatorIndex + 1).trim();
+    data[key] = value;
+  }
+
+  for (const field of ["title", "description", "date"]) {
+    if (!data[field]) {
+      throw new Error(`Missing frontmatter field: ${field}`);
+    }
+  }
+
+  if (data.tags) {
+    data.tags = data.tags
+      .split(",")
+      .map((tag) => tag.trim())
+      .filter(Boolean);
+  } else {
+    data.tags = [];
+  }
+
+  return { data, content: content.trim() };
+}
+
+function renderInlineMarkdown(text) {
+  const linkedText = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, href) => {
+    const safeLabel = escapeHtml(label);
+    const safeHref = escapeHtml(sanitizeHref(href));
+    return `<a href="${safeHref}">${safeLabel}</a>`;
+  });
+
+  return escapeHtml(linkedText)
+    .replace(/&lt;a href=&quot;(.+?)&quot;&gt;(.+?)&lt;\/a&gt;/g, '<a href="$1">$2</a>')
+    .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
+    .replace(/\*(.+?)\*/g, "<em>$1</em>")
+    .replace(/`(.+?)`/g, "<code>$1</code>");
+}
+
+function markdownToHtml(markdown) {
+  const lines = markdown.split("\n");
+  const html = [];
+  let inList = false;
+  let listType = null;
+  let inCodeBlock = false;
+  let codeBuffer = [];
+
+  const flushList = () => {
+    if (inList) {
+      html.push(listType === "ol" ? "</ol>" : "</ul>");
+      inList = false;
+      listType = null;
+    }
+  };
+
+  const flushCodeBlock = () => {
+    if (inCodeBlock) {
+      html.push(`<pre><code>${escapeHtml(codeBuffer.join("\n"))}</code></pre>`);
+      inCodeBlock = false;
+      codeBuffer = [];
+    }
+  };
+
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      flushList();
+      if (inCodeBlock) {
+        flushCodeBlock();
+      } else {
+        inCodeBlock = true;
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeBuffer.push(line);
+      continue;
+    }
+
+    const trimmed = line.trim();
+
+    if (!trimmed) {
+      flushList();
+      continue;
+    }
+
+    if (trimmed.startsWith("# ")) {
+      flushList();
+      html.push(`<h1>${renderInlineMarkdown(trimmed.slice(2))}</h1>`);
+      continue;
+    }
+
+    if (trimmed.startsWith("## ")) {
+      flushList();
+      html.push(`<h2>${renderInlineMarkdown(trimmed.slice(3))}</h2>`);
+      continue;
+    }
+
+    if (trimmed.startsWith("### ")) {
+      flushList();
+      html.push(`<h3>${renderInlineMarkdown(trimmed.slice(4))}</h3>`);
+      continue;
+    }
+
+    if (trimmed.startsWith("- ")) {
+      if (!inList || listType !== "ul") {
+        flushList();
+        html.push("<ul>");
+        inList = true;
+        listType = "ul";
+      }
+      html.push(`<li>${renderInlineMarkdown(trimmed.slice(2))}</li>`);
+      continue;
+    }
+
+    if (/^\d+\.\s/.test(trimmed)) {
+      if (!inList || listType !== "ol") {
+        flushList();
+        html.push("<ol>");
+        inList = true;
+        listType = "ol";
+      }
+      html.push(`<li>${renderInlineMarkdown(trimmed.replace(/^\d+\.\s/, ""))}</li>`);
+      continue;
+    }
+
+    if (trimmed.startsWith("> ")) {
+      flushList();
+      html.push(`<blockquote><p>${renderInlineMarkdown(trimmed.slice(2))}</p></blockquote>`);
+      continue;
+    }
+
+    flushList();
+    html.push(`<p>${renderInlineMarkdown(trimmed)}</p>`);
+  }
+
+  flushList();
+  flushCodeBlock();
+
+  return html.join("\n");
+}
+
+function stripDuplicateTitleHeading(markdown, title) {
+  const lines = markdown.split("\n");
+  const firstContentLine = lines.findIndex((line) => line.trim());
+
+  if (firstContentLine === -1) {
+    return markdown;
+  }
+
+  const firstLine = lines[firstContentLine].trim();
+  if (firstLine === `# ${title}`) {
+    lines.splice(firstContentLine, 1);
+  }
+
+  return lines.join("\n").trim();
+}
+
+function applyTemplate(template, variables) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => variables[key] ?? "");
+}
+
+export async function loadTemplate(config, name) {
+  const templatePath = path.join(config.templatesDir, name);
+  return fs.readFile(templatePath, "utf8");
+}
+
+export async function renderPostPage(config, post) {
+  const template = await loadTemplate(config, "post.html");
+  const cleanedContent = stripDuplicateTitleHeading(post.content, post.title);
+  const tagsMarkup = post.tags
+    .map((tag) => `<li class="tag">${escapeHtml(tag)}</li>`)
+    .join("");
+
+  return applyTemplate(template, {
+    title: escapeHtml(post.title),
+    description: escapeHtml(post.description),
+    date: escapeHtml(post.date),
+    author: escapeHtml(post.author || "sharq"),
+    tags: tagsMarkup,
+    content: markdownToHtml(cleanedContent)
+  });
+}
+
+export async function renderIndexPage(config, posts) {
+  const template = await loadTemplate(config, "index.html");
+  const items = posts
+    .map(
+      (post) =>
+        `<li><div><a href="/blog/${post.slug}">${escapeHtml(post.title)}</a><p>${escapeHtml(post.description)}</p></div><span>${escapeHtml(post.date)}</span></li>`
+    )
+    .join("\n");
+
+  return applyTemplate(template, {
+    title: escapeHtml(config.siteTitle),
+    description: escapeHtml(config.siteDescription),
+    date: "",
+    content: items || "<li>No posts available yet.</li>"
+  });
+}
+
+export async function renderArchivePage(config, posts) {
+  const template = await loadTemplate(config, "archive.html");
+  const items = posts
+    .map((post) => {
+      const tagMarkup = post.tags.map((tag) => `<li class="tag">${escapeHtml(tag)}</li>`).join("");
+      return `
+        <article class="archive-item">
+          <div class="archive-heading">
+            <p class="eyebrow">${escapeHtml(post.date)}</p>
+            <h2><a href="/blog/${post.slug}">${escapeHtml(post.title)}</a></h2>
+          </div>
+          <p>${escapeHtml(post.description)}</p>
+          <p class="archive-meta">By ${escapeHtml(post.author || "sharq")}</p>
+          <ul class="tag-list">${tagMarkup}</ul>
+        </article>
+      `;
+    })
+    .join("\n");
+
+  return applyTemplate(template, {
+    title: `Archive | ${escapeHtml(config.siteTitle)}`,
+    description: escapeHtml(`Browse all posts on ${config.siteTitle}`),
+    date: "",
+    content: items || "<p>No posts available yet.</p>"
+  });
+}
+
+export async function readPostSource(config, slug) {
+  const filePath = path.join(config.contentDir, `${slug}.md`);
+  const markdown = await fs.readFile(filePath, "utf8");
+  const { data, content } = parseFrontmatter(markdown);
+
+  return {
+    slug,
+    title: data.title,
+    description: data.description,
+    date: data.date,
+    author: data.author || "",
+    tags: data.tags,
+    content
+  };
+}

package/lib/scaffold.js

@@ -0,0 +1,161 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+function toSlug(value) {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function titleFromName(value) {
+  return value
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+async function ensureEmptyOrNewDirectory(projectDir) {
+  try {
+    const entries = await fs.readdir(projectDir);
+    if (entries.length > 0) {
+      throw new Error(`Target directory is not empty: ${projectDir}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      await fs.mkdir(projectDir, { recursive: true });
+      return;
+    }
+
+    throw error;
+  }
+}
+
+async function copyDir(sourceDir, targetDir) {
+  await fs.mkdir(targetDir, { recursive: true });
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDir(sourcePath, targetPath);
+    } else {
+      await fs.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+function normalizeDependencySpec(spec) {
+  if (!spec) {
+    return "latest";
+  }
+
+  return spec;
+}
+
+function resolveLocalDependencySpec(projectDir, packageRoot) {
+  const relativePath = path.relative(projectDir, packageRoot) || ".";
+  return `file:${relativePath}`;
+}
+
+async function writePackageJson(projectDir, projectName, frameworkDependency) {
+  const packageJson = {
+    name: projectName,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "sharq dev",
+      start: "sharq start",
+      build: "sharq build"
+    },
+    dependencies: {
+      sharq: frameworkDependency
+    }
+  };
+
+  await fs.writeFile(path.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+}
+
+async function writeConfig(projectDir, { siteTitle, siteDescription }) {
+  const configSource = `export default {
+  siteTitle: ${JSON.stringify(siteTitle)},
+  siteDescription: ${JSON.stringify(siteDescription)}
+};
+`;
+
+  await fs.writeFile(path.join(projectDir, "sharq.config.js"), configSource, "utf8");
+}
+
+async function writeReadme(projectDir, { projectName }) {
+  const readme = `# ${projectName}
+
+Generated with sharq.
+
+## Scripts
+
+- \`npm run dev\`
+- \`npm start\`
+- \`npm run build\`
+
+## Structure
+
+- \`content/\` markdown posts
+- \`templates/\` page templates
+- \`public/assets/\` static assets
+- \`sharq/\` production build output
+- \`sharq.config.js\` project-level settings
+`;
+
+  await fs.writeFile(path.join(projectDir, "README.md"), readme, "utf8");
+}
+
+export async function scaffoldProject(options = {}) {
+  const packageRoot = options.packageRoot;
+
+  let answers = {
+    projectName: options.projectName || "",
+    siteTitle: options.siteTitle || "",
+    siteDescription: options.siteDescription || ""
+  };
+
+  if (!answers.projectName) {
+    const rl = readline.createInterface({ input, output });
+    const requestedName = await rl.question("Project name: ");
+    const projectName = toSlug(requestedName) || "my-sharq-site";
+    const siteTitleInput = await rl.question(`Site title (${titleFromName(projectName)}): `);
+    const siteDescriptionInput = await rl.question("Site description (A sharq site): ");
+    rl.close();
+
+    answers = {
+      projectName,
+      siteTitle: siteTitleInput.trim() || titleFromName(projectName),
+      siteDescription: siteDescriptionInput.trim() || "A sharq site"
+    };
+  } else {
+    answers.projectName = toSlug(answers.projectName);
+    answers.siteTitle = answers.siteTitle || titleFromName(answers.projectName);
+    answers.siteDescription = answers.siteDescription || "A sharq site";
+  }
+
+  const projectDir = path.resolve(process.cwd(), answers.projectName);
+  await ensureEmptyOrNewDirectory(projectDir);
+
+  const frameworkDependency = options.useLocalDependency
+    ? resolveLocalDependencySpec(projectDir, packageRoot)
+    : normalizeDependencySpec(options.frameworkVersion);
+
+  const templateDir = path.join(packageRoot, "scaffold", "template");
+  await copyDir(templateDir, projectDir);
+  await writePackageJson(projectDir, answers.projectName, frameworkDependency);
+  await writeConfig(projectDir, answers);
+  await writeReadme(projectDir, answers);
+
+  return { projectDir, frameworkDependency, ...answers };
+}

package/lib/server.js

@@ -0,0 +1,199 @@
+import fs from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { resolveConfig } from "./config.js";
+import { ensurePostGenerated, refreshSiteArtifacts } from "./generator.js";
+
+const contentTypes = {
+  ".html": "text/html; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".txt": "text/plain; charset=utf-8"
+};
+
+async function sendFile(response, filePath) {
+  const extension = path.extname(filePath);
+  const body = await fs.readFile(filePath);
+  response.writeHead(200, { "Content-Type": contentTypes[extension] || "text/plain; charset=utf-8" });
+  response.end(body);
+}
+
+function sendHtml(response, statusCode, html) {
+  response.writeHead(statusCode, { "Content-Type": "text/html; charset=utf-8" });
+  response.end(html);
+}
+
+function logRequest(method, pathname, statusCode) {
+  console.log(`[sharq] ${method} ${pathname} -> ${statusCode}`);
+}
+
+function notFound(response, message = "Page not found.") {
+  sendHtml(response, 404, `<!doctype html><html><body><h1>404</h1><p>${message}</p></body></html>`);
+}
+
+async function servePublicPath(config, response, pathname) {
+  const relativePath = pathname.replace(/^\/+/, "");
+  const filePath = path.resolve(config.publicDir, relativePath);
+
+  if (!filePath.startsWith(config.publicDir)) {
+    throw new Error("Invalid public asset path.");
+  }
+
+  await sendFile(response, filePath);
+}
+
+function createApp(config) {
+  let isReady = false;
+
+  async function handleRequest(request, response) {
+    if (!request.url) {
+      notFound(response);
+      return;
+    }
+
+    const url = new URL(request.url, config.siteUrl);
+    const { pathname } = url;
+
+    try {
+      if (!isReady) {
+        sendHtml(
+          response,
+          503,
+          "<!doctype html><html><body><h1>503</h1><p>sharq is still preparing generated files.</p></body></html>"
+        );
+        logRequest(request.method || "GET", pathname, 503);
+        return;
+      }
+
+      if (pathname === "/") {
+        await refreshSiteArtifacts(config);
+        await sendFile(response, config.homePagePath);
+        logRequest(request.method || "GET", pathname, 200);
+        return;
+      }
+
+      if (pathname === "/sitemap.xml") {
+        await refreshSiteArtifacts(config);
+        await sendFile(response, config.sitemapPath);
+        logRequest(request.method || "GET", pathname, 200);
+        return;
+      }
+
+      if (pathname === "/archive") {
+        await refreshSiteArtifacts(config);
+        await sendFile(response, config.archivePagePath);
+        logRequest(request.method || "GET", pathname, 200);
+        return;
+      }
+
+      if (pathname.startsWith("/blog/")) {
+        const slug = pathname.replace("/blog/", "").replace(/\/+$/, "");
+
+        if (!slug) {
+          notFound(response, "Missing blog slug.");
+          return;
+        }
+
+        const filePath = await ensurePostGenerated(config, slug);
+        await sendFile(response, filePath);
+        logRequest(request.method || "GET", pathname, 200);
+        return;
+      }
+
+      if (pathname.startsWith("/assets/")) {
+        await servePublicPath(config, response, pathname);
+        logRequest(request.method || "GET", pathname, 200);
+        return;
+      }
+
+      notFound(response);
+      logRequest(request.method || "GET", pathname, 404);
+    } catch (error) {
+      if (error && error.code === "ENOENT") {
+        notFound(response, "Requested content does not exist.");
+        logRequest(request.method || "GET", pathname, 404);
+        return;
+      }
+
+      if (error instanceof Error && error.message === "Invalid slug format.") {
+        notFound(response, "Invalid blog slug.");
+        logRequest(request.method || "GET", pathname, 404);
+        return;
+      }
+
+      if (error instanceof Error && error.message === "Invalid public asset path.") {
+        notFound(response, "Invalid asset path.");
+        logRequest(request.method || "GET", pathname, 404);
+        return;
+      }
+
+      sendHtml(
+        response,
+        500,
+        `<!doctype html><html><body><h1>500</h1><p>${String(error.message || error)}</p></body></html>`
+      );
+      logRequest(request.method || "GET", pathname, 500);
+    }
+  }
+
+  async function prepare() {
+    await refreshSiteArtifacts(config);
+    isReady = true;
+  }
+
+  function createServer() {
+    return http.createServer((request, response) => {
+      handleRequest(request, response);
+    });
+  }
+
+  return { prepare, createServer };
+}
+
+function listenOnAvailablePort(createServerInstance, port, attemptsLeft) {
+  return new Promise((resolve, reject) => {
+    const server = createServerInstance();
+
+    const handleError = (error) => {
+      server.close();
+
+      if (error.code === "EADDRINUSE" && attemptsLeft > 0) {
+        resolve(listenOnAvailablePort(createServerInstance, port + 1, attemptsLeft - 1));
+        return;
+      }
+
+      reject(error);
+    };
+
+    server.once("error", handleError);
+    server.listen(port, () => {
+      server.off("error", handleError);
+      resolve({ server, port });
+    });
+  });
+}
+
+export async function startServer(options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const config = await resolveConfig(rootDir);
+  const requestedPort = Number(options.port || process.env.PORT || 3000);
+  const maxPortAttempts = Number(options.maxPortAttempts || 20);
+  const app = createApp(config);
+  const { server, port } = await listenOnAvailablePort(() => app.createServer(), requestedPort, maxPortAttempts);
+
+  if (!process.env.SITE_URL) {
+    config.siteUrl = `http://localhost:${port}`;
+  }
+
+  await app.prepare();
+  console.log(`sharq running at http://localhost:${port}`);
+  return { server, port, config };
+}

package/lib/sitemap.js

@@ -0,0 +1,21 @@
+import fs from "node:fs/promises";
+
+function buildUrl(config, pathname) {
+  return `${config.siteUrl}${pathname}`;
+}
+
+export async function generateSitemap(config, posts) {
+  const urls = [
+    buildUrl(config, "/"),
+    buildUrl(config, "/archive"),
+    ...posts.map((post) => buildUrl(config, `/blog/${post.slug}`))
+  ];
+
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls.map((url) => `  <url><loc>${url}</loc></url>`).join("\n")}
+</urlset>
+`;
+
+  await fs.writeFile(config.sitemapPath, xml, "utf8");
+}