@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/seo.js

@@ -0,0 +1,486 @@
+import { ErrorCodes, inlineError } from "./error-handling.js";
+import { mergeHeadConfigs } from "./head.js";
+import { safeEvaluateObject } from "./safe-evaluator.js";
+export function processMetaDirectives(template, context, _filePath, _options) {
+  let output = template;
+  output = output.replace(/@meta\(\s*['"]([^'"]+)['"](?:,\s*['"]([^'"]+)['"]\s*)?\)/g, (_, name, content) => {
+    if (!content && name.includes(":")) {
+      const parts = name.split(":"), property = name, contextKey = parts.length > 1 ? parts[1] : "";
+      if (contextKey && context[contextKey])
+        content = context[contextKey];
+      else if (property.startsWith("og:") && context.openGraph && context.openGraph[parts[1]])
+        content = context.openGraph[parts[1]];
+      else
+        content = "";
+      return content ? `<meta property="${escapeHtml(property)}" content="${escapeHtml(content)}">` : "";
+    }
+    return content ? `<meta name="${escapeHtml(name)}" content="${escapeHtml(content)}">` : "";
+  });
+  const metaTagPat = /@metaTag\s*\(/g;
+  let metaMatch;
+  while ((metaMatch = metaTagPat.exec(output)) !== null) {
+    const mtStart = metaMatch.index, openP = mtStart + metaMatch[0].length - 1;
+    let d = 1, p = openP + 1;
+    while (p < output.length && d > 0) {
+      if (output[p] === "(")
+        d++;
+      else if (output[p] === ")") {
+        d--;
+        if (d === 0)
+          break;
+      }
+      p++;
+    }
+    if (d !== 0)
+      break;
+    const attrObject = output.substring(openP + 1, p).trim(), fullEnd = p + 1, mtReplacement = (() => {
+      try {
+        const attrs = safeEvaluateObject(attrObject, context);
+        if (!attrs)
+          return "";
+        let tag = "<meta";
+        if (attrs.name)
+          tag += ` name="${escapeHtml(String(attrs.name))}"`;
+        if (attrs.property)
+          tag += ` property="${escapeHtml(String(attrs.property))}"`;
+        if (attrs.httpEquiv)
+          tag += ` http-equiv="${escapeHtml(String(attrs.httpEquiv))}"`;
+        if (attrs.content)
+          tag += ` content="${escapeHtml(String(attrs.content))}"`;
+        tag += ">";
+        return tag;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return inlineError("MetaTag", errorMessage, ErrorCodes.EVALUATION_ERROR);
+      }
+    })();
+    output = output.substring(0, mtStart) + mtReplacement + output.substring(fullEnd);
+    metaTagPat.lastIndex = 0;
+  }
+  return output;
+}
+export function processStructuredData(template, context, _filePath) {
+  let output = template;
+  const structuredDataPattern = /@structuredData\s*\(/g;
+  let sdMatch;
+  while ((sdMatch = structuredDataPattern.exec(output)) !== null) {
+    const sdStart = sdMatch.index, openParen = sdStart + sdMatch[0].length - 1;
+    let depth = 1, pos = openParen + 1;
+    while (pos < output.length && depth > 0) {
+      if (output[pos] === "(")
+        depth++;
+      else if (output[pos] === ")") {
+        depth--;
+        if (depth === 0)
+          break;
+      }
+      pos++;
+    }
+    if (depth !== 0)
+      break;
+    const dataObject = output.substring(openParen + 1, pos).trim(), fullEnd = pos + 1, replacement = (() => {
+      try {
+        const data = safeEvaluateObject(dataObject, context);
+        if (!data)
+          return "";
+        if (!data["@context"])
+          data["@context"] = "https://schema.org";
+        return `<script type="application/ld+json">${JSON.stringify(data).replace(/<\//g, "<\\/")}</script>`;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return inlineError("StructuredData", errorMessage, ErrorCodes.EVALUATION_ERROR);
+      }
+    })();
+    output = output.substring(0, sdStart) + replacement + output.substring(fullEnd);
+    structuredDataPattern.lastIndex = 0;
+  }
+  return output;
+}
+export function processSeoDirective(template, context, _filePath, _options) {
+  let output = template;
+  const seoPat = /@seo\s*\(\s*\{/g;
+  let seoMatch;
+  while ((seoMatch = seoPat.exec(output)) !== null) {
+    const braceStart = output.indexOf("{", seoMatch.index + 4);
+    let depth = 1, pos = braceStart + 1, inStr = null, esc = !1;
+    while (pos < output.length && depth > 0) {
+      const c = output[pos];
+      if (esc) {
+        esc = !1;
+        pos++;
+        continue;
+      }
+      if (c === "\\" && inStr) {
+        esc = !0;
+        pos++;
+        continue;
+      }
+      if (inStr) {
+        if (c === inStr)
+          inStr = null;
+        pos++;
+        continue;
+      }
+      if (c === '"' || c === "'" || c === "`") {
+        inStr = c;
+        pos++;
+        continue;
+      }
+      if (c === "{")
+        depth++;
+      else if (c === "}")
+        depth--;
+      pos++;
+    }
+    if (depth !== 0)
+      break;
+    const afterBrace = output.substring(pos).match(/^\s*\)/);
+    if (!afterBrace)
+      break;
+    const fullEnd = pos + afterBrace[0].length, seoConfig = output.substring(braceStart, pos), fullMatch = output.substring(seoMatch.index, fullEnd), replacement = ((cfg) => {
+      try {
+        const config = safeEvaluateObject(cfg, context);
+        if (!config)
+          return "";
+        let metaTags = "";
+        if (config.title) {
+          metaTags += `<title>${escapeHtml(config.title)}</title>
+`;
+          metaTags += `<meta name="title" content="${escapeHtml(config.title)}">
+`;
+        }
+        if (config.description)
+          metaTags += `<meta name="description" content="${escapeHtml(config.description)}">
+`;
+        if (config.keywords) {
+          const keywordsStr = Array.isArray(config.keywords) ? config.keywords.join(", ") : config.keywords;
+          metaTags += `<meta name="keywords" content="${escapeHtml(keywordsStr)}">
+`;
+        }
+        if (config.robots)
+          metaTags += `<meta name="robots" content="${escapeHtml(config.robots)}">
+`;
+        if (config.canonical)
+          metaTags += `<link rel="canonical" href="${escapeHtml(config.canonical)}">
+`;
+        if (config.openGraph) {
+          const og = config.openGraph;
+          metaTags += `<meta property="og:type" content="${escapeHtml(og.type || "website")}">
+`;
+          if (og.title || config.title) {
+            const ogTitle = og.title || config.title || "";
+            metaTags += `<meta property="og:title" content="${escapeHtml(ogTitle)}">
+`;
+          }
+          if (og.description || config.description) {
+            const ogDescription = og.description || config.description || "";
+            metaTags += `<meta property="og:description" content="${escapeHtml(ogDescription)}">
+`;
+          }
+          if (og.url || config.canonical) {
+            const ogUrl = og.url || config.canonical || "";
+            metaTags += `<meta property="og:url" content="${escapeHtml(ogUrl)}">
+`;
+          }
+          if (og.image) {
+            metaTags += `<meta property="og:image" content="${escapeHtml(og.image)}">
+`;
+            if (og.imageAlt)
+              metaTags += `<meta property="og:image:alt" content="${escapeHtml(og.imageAlt)}">
+`;
+            if (og.imageWidth)
+              metaTags += `<meta property="og:image:width" content="${escapeHtml(String(og.imageWidth))}">
+`;
+            if (og.imageHeight)
+              metaTags += `<meta property="og:image:height" content="${escapeHtml(String(og.imageHeight))}">
+`;
+          }
+          if (og.siteName)
+            metaTags += `<meta property="og:site_name" content="${escapeHtml(og.siteName)}">
+`;
+        }
+        if (config.twitter) {
+          const twitter = config.twitter;
+          metaTags += `<meta name="twitter:card" content="${escapeHtml(twitter.card || "summary_large_image")}">
+`;
+          if (twitter.title || config.title) {
+            const twitterTitle = twitter.title || config.title || "";
+            metaTags += `<meta name="twitter:title" content="${escapeHtml(twitterTitle)}">
+`;
+          }
+          if (twitter.description || config.description) {
+            const twitterDesc = twitter.description || config.description || "";
+            metaTags += `<meta name="twitter:description" content="${escapeHtml(twitterDesc)}">
+`;
+          }
+          if (twitter.image || config.openGraph && config.openGraph.image) {
+            const twitterImage = twitter.image || (config.openGraph ? config.openGraph.image : "") || "";
+            metaTags += `<meta name="twitter:image" content="${escapeHtml(twitterImage)}">
+`;
+          }
+          if (twitter.site)
+            metaTags += `<meta name="twitter:site" content="${escapeHtml(twitter.site)}">
+`;
+          if (twitter.creator)
+            metaTags += `<meta name="twitter:creator" content="${escapeHtml(twitter.creator)}">
+`;
+        }
+        if (config.structuredData) {
+          const jsonStr = JSON.stringify(config.structuredData).replace(/<\//g, "<\\/");
+          metaTags += `<script type="application/ld+json">${jsonStr}</script>
+`;
+        }
+        return metaTags.trim();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return inlineError("SEO", `Error processing @seo directive: ${errorMessage}`, ErrorCodes.EVALUATION_ERROR);
+      }
+    })(seoConfig);
+    output = output.substring(0, seoMatch.index) + replacement + output.substring(fullEnd);
+    seoPat.lastIndex = seoMatch.index + replacement.length;
+  }
+  return output;
+}
+export function injectSeoTags(html, context, options) {
+  if (options.seo?.enabled === !1)
+    return html;
+  if (html.includes("<!-- stx SEO Tags -->") || context.__stx_seo_staged === !0 || options.skipDefaultSeoTags === !0)
+    return html;
+  const runtimeHead = context.__stx_runtime_head;
+  if (!!(runtimeHead?.title || runtimeHead?.meta?.some((m) => m.property === "og:title" || m.name === "og:title" || m.name === "twitter:title" || m.name === "description")))
+    return html;
+  if (/<meta\s+(?:[^>]*\s)?property=["']og:title["']/i.test(html) || /<meta\s+(?:[^>]*\s)?name=["']og:title["']/i.test(html) || /<meta\s+(?:[^>]*\s)?name=["']twitter:title["']/i.test(html))
+    return html;
+  if (!html.includes("<head>") && !html.includes("<head "))
+    return html;
+  const hasTitle = html.includes("<title>") || html.includes("</title>");
+  let title = "";
+  if (context.title)
+    title = context.title;
+  else if (context.meta && context.meta.title)
+    title = context.meta.title;
+  else if (options.seo?.defaultConfig?.title)
+    title = options.seo.defaultConfig.title;
+  else
+    title = options.defaultTitle || "stx Project";
+  let description = "";
+  if (context.description)
+    description = context.description;
+  else if (context.meta && context.meta.description)
+    description = context.meta.description;
+  else if (options.seo?.defaultConfig?.description)
+    description = options.seo.defaultConfig.description;
+  else
+    description = options.defaultDescription || "A website built with stx templating engine";
+  let image = "";
+  if (context.image)
+    image = context.image;
+  else if (context.meta && context.meta.image)
+    image = context.meta.image;
+  else if (context.openGraph && context.openGraph.image)
+    image = context.openGraph.image;
+  else if (options.seo?.defaultImage)
+    image = options.seo.defaultImage;
+  else if (options.defaultImage)
+    image = options.defaultImage;
+  let seoTagsMinimal = `
+<!-- stx SEO Tags -->
+<meta name="title" content="${escapeHtml(title)}">
+<meta name="description" content="${escapeHtml(description)}">
+<meta property="og:title" content="${escapeHtml(title)}">
+<meta property="og:description" content="${escapeHtml(description)}">
+<meta property="og:type" content="website">
+<meta name="twitter:card" content="summary_large_image">
+<meta name="twitter:title" content="${escapeHtml(title)}">
+<meta name="twitter:description" content="${escapeHtml(description)}">
+`;
+  if (image)
+    seoTagsMinimal += `
+<meta property="og:image" content="${escapeHtml(image)}">
+<meta name="twitter:image" content="${escapeHtml(image)}">
+`;
+  let result = html;
+  if (!hasTitle)
+    result = result.replace(/<head[^>]*>/, `$&
+<title>${escapeHtml(title)}</title>`);
+  const staged = context.__stx_head_injections;
+  if (staged) {
+    context.__stx_seo_staged = !0;
+    staged.afterOpen.push(`
+${seoTagsMinimal}
+`);
+    return result;
+  }
+  return result.replace(/<head[^>]*>/, `$&
+${seoTagsMinimal}
+`);
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+const PROPERTY_NAMESPACES = ["og:", "article:", "book:", "profile:", "fb:", "music:", "video:"];
+function unquoteParam(raw) {
+  const text = raw.trim(), first = text[0];
+  if ((first === "'" || first === '"' || first === "`") && text.length > 1 && text.at(-1) === first)
+    return { value: text.slice(1, -1), quoted: !0 };
+  return { value: text, quoted: !1 };
+}
+export const metaDirective = {
+  name: "meta",
+  handler: (_content, params, context, _filePath) => {
+    if (params.length < 1)
+      return inlineError("Meta", "meta directive requires at least the meta name", ErrorCodes.INVALID_DIRECTIVE_SYNTAX);
+    const name = unquoteParam(params[0]).value;
+    let metaContent;
+    if (params.length > 1) {
+      const arg = unquoteParam(params[1]);
+      metaContent = arg.quoted ? arg.value : String(context?.[arg.value] ?? arg.value);
+    } else {
+      const segment = name.includes(":") ? name.slice(name.indexOf(":") + 1) : name, openGraph = context?.openGraph;
+      metaContent = String(context?.[segment] ?? openGraph?.[segment] ?? "");
+    }
+    if (!metaContent)
+      return "";
+    const tag = PROPERTY_NAMESPACES.some((prefix) => name.startsWith(prefix)) ? { property: name, content: metaContent } : { name, content: metaContent };
+    if (context)
+      context.__stx_runtime_head = mergeHeadConfigs(context.__stx_runtime_head ?? {}, { meta: [tag] });
+    return "";
+  },
+  hasEndTag: !1
+}, structuredDataDirective = {
+  name: "structuredData",
+  handler: (content, _params, _context, _filePath) => {
+    if (content.trim() === "")
+      return inlineError("StructuredData", "structuredData directive requires JSON-LD content", ErrorCodes.INVALID_DIRECTIVE_SYNTAX);
+    try {
+      const data = JSON.parse(content);
+      if (!data["@context"])
+        data["@context"] = "https://schema.org";
+      if (!data["@type"])
+        return inlineError("StructuredData", "structuredData requires @type property", ErrorCodes.INVALID_DIRECTIVE_SYNTAX);
+      return `<script type="application/ld+json">${JSON.stringify(data)}</script>`;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return inlineError("StructuredData", errorMessage, ErrorCodes.EVALUATION_ERROR);
+    }
+  },
+  hasEndTag: !0
+};
+export function registerSeoDirectives() {
+  return [
+    metaDirective,
+    structuredDataDirective
+  ];
+}
+export function generateSitemap(entries, options) {
+  const {
+    baseUrl,
+    defaultChangefreq = "weekly",
+    defaultPriority = 0.5,
+    includeLastmod = !0
+  } = options, base = baseUrl.replace(/\/$/, "");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${entries.map((entry) => {
+    const loc = entry.loc.startsWith("http") ? entry.loc : `${base}${entry.loc.startsWith("/") ? "" : "/"}${entry.loc}`, lastmod = entry.lastmod || (includeLastmod ? new Date().toISOString().split("T")[0] : void 0), changefreq = entry.changefreq || defaultChangefreq, priority = entry.priority ?? defaultPriority;
+    let urlXml = `  <url>
+    <loc>${escapeXml(loc)}</loc>`;
+    if (lastmod)
+      urlXml += `
+    <lastmod>${lastmod}</lastmod>`;
+    urlXml += `
+    <changefreq>${changefreq}</changefreq>`;
+    urlXml += `
+    <priority>${priority.toFixed(1)}</priority>`;
+    urlXml += `
+  </url>`;
+    return urlXml;
+  }).join(`
+`)}
+</urlset>`;
+}
+export function generateSitemapIndex(sitemaps, baseUrl) {
+  const base = baseUrl.replace(/\/$/, ""), lastmod = new Date().toISOString().split("T")[0];
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sitemaps.map((sitemap) => {
+    const loc = sitemap.startsWith("http") ? sitemap : `${base}${sitemap.startsWith("/") ? "" : "/"}${sitemap}`;
+    return `  <sitemap>
+    <loc>${escapeXml(loc)}</loc>
+    <lastmod>${lastmod}</lastmod>
+  </sitemap>`;
+  }).join(`
+`)}
+</sitemapindex>`;
+}
+export async function scanForSitemapEntries(directory, options) {
+  const {
+    extensions = [".stx", ".html", ".htm"],
+    ignore = ["_*", ".*", "node_modules", "components", "partials", "layouts"]
+  } = options, entries = [], extPattern = extensions.length === 1 ? `*${extensions[0]}` : `*{${extensions.join(",")}}`, glob = new Bun.Glob(`**/${extPattern}`);
+  for await (const file of glob.scan(directory)) {
+    if (ignore.some((pattern) => {
+      if (pattern.startsWith("*"))
+        return file.includes(pattern.slice(1));
+      return file.startsWith(pattern) || file.includes(`/${pattern}`);
+    }))
+      continue;
+    let urlPath = file.replace(/\\/g, "/").replace(/index\.(stx|html|htm)$/, "").replace(/\.(stx|html|htm)$/, "");
+    if (!urlPath.startsWith("/"))
+      urlPath = `/${urlPath}`;
+    if (urlPath !== "/" && urlPath.endsWith("/"))
+      urlPath = urlPath.slice(0, -1);
+    const filePath = `${directory}/${file}`;
+    let lastmod;
+    try {
+      const stat = await Bun.file(filePath).stat();
+      if (stat)
+        lastmod = new Date(stat.mtime).toISOString().split("T")[0];
+    } catch {}
+    entries.push({
+      loc: urlPath || "/",
+      lastmod,
+      priority: urlPath === "/" ? 1 : 0.5
+    });
+  }
+  entries.sort((a, b) => a.loc.localeCompare(b.loc));
+  return entries;
+}
+export function generateRobotsTxt(options) {
+  const lines = [];
+  for (const rule of options.rules) {
+    lines.push(`User-agent: ${rule.userAgent}`);
+    if (rule.allow)
+      for (const path of rule.allow)
+        lines.push(`Allow: ${path}`);
+    if (rule.disallow)
+      for (const path of rule.disallow)
+        lines.push(`Disallow: ${path}`);
+    if (rule.crawlDelay !== void 0)
+      lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+    lines.push("");
+  }
+  if (options.sitemap) {
+    const sitemaps = Array.isArray(options.sitemap) ? options.sitemap : [options.sitemap];
+    for (const sitemap of sitemaps)
+      lines.push(`Sitemap: ${sitemap}`);
+  }
+  if (options.host)
+    lines.push(`Host: ${options.host}`);
+  return lines.join(`
+`).trim();
+}
+export function generateDefaultRobotsTxt(sitemapUrl) {
+  return generateRobotsTxt({
+    rules: [
+      {
+        userAgent: "*",
+        allow: ["/"]
+      }
+    ],
+    sitemap: sitemapUrl
+  });
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}

package/dist/serve.d.ts

@@ -0,0 +1,44 @@
+import type { Server } from 'bun';
+import type { StxOptions } from './types';
+/**
+ * Create an HTML response helper
+ */
+export declare function htmlResponse(html: string, status?: number, headers?: Record<string, string>): Response;
+/**
+ * Serve a directory of stx templates and markdown files
+ * This is the main function for programmatic usage
+ */
+export declare function serve(options?: ServeOptions): Promise<ServeResult>;
+/**
+ * Serve a single stx or markdown file
+ */
+export declare function serveFile(filePath: string, options?: Omit<ServeOptions, 'root'>): Promise<ServeResult>;
+/**
+ * Create a middleware function
+ */
+export declare function createMiddleware(handler: (request: Request, next: () => Response | Promise<Response>) => Response | Promise<Response>): (request: Request, next: () => Response | Promise<Response>) => Response | Promise<Response>;
+/**
+ * Helper to create a route handler
+ */
+export declare function createRoute(handler: (request: Request) => Response | Promise<Response>): (request: Request) => Response | Promise<Response>;
+export declare interface ServeOptions {
+  port?: number
+  root?: string
+  configDir?: string
+  stxOptions?: StxOptions
+  watch?: boolean
+  onRequest?: (request: Request) =>
+    | Response
+    | null
+    | undefined
+    | Promise<Response | null | undefined>
+  routes?: Record<string, (request: Request) => Response | Promise<Response>>
+  middleware?: Array<(request: Request, next: () => Response | Promise<Response>) => Response | Promise<Response>>
+  on404?: (request: Request) => Response | Promise<Response>
+  onError?: (error: Error, request: Request) => Response | Promise<Response>
+}
+export declare interface ServeResult {
+  server: Server<any>
+  stop: () => void
+  url: string
+}