studiocms 0.1.0-beta.10

package/dist/lib/renderer/contentRenderer.js

@@ -0,0 +1,31 @@
+import rendererConfig from "studiocms:renderer/config";
+import renderAstroMD from "./astro-remark.js";
+import renderMarkDoc from "./markdoc.js";
+import renderAstroMDX from "./mdx.js";
+import renderStudioCMS from "./studiocms.js";
+const { renderer } = rendererConfig;
+async function contentRenderer(content, SSRResult) {
+  if (typeof renderer === "object") {
+    if (!renderer.renderer || !renderer.name) {
+      throw new Error("Invalid custom renderer");
+    }
+    return await renderer.renderer(content);
+  }
+  switch (renderer) {
+    case "studiocms":
+      return await renderStudioCMS(content, SSRResult);
+    case "astro":
+      return await renderAstroMD(content);
+    case "markdoc":
+      return await renderMarkDoc(content);
+    case "mdx":
+      return await renderAstroMDX(content);
+    default:
+      return await renderAstroMD(content);
+  }
+}
+var contentRenderer_default = contentRenderer;
+export {
+  contentRenderer,
+  contentRenderer_default as default
+};

package/dist/lib/renderer/errors.d.ts

@@ -0,0 +1,5 @@
+import { StudioCMSCoreError } from '../../errors.js';
+export declare class StudioCMSRendererError extends StudioCMSCoreError {
+    name: string;
+}
+export declare function prefixError(err: any, prefix: string): any;

package/dist/lib/renderer/errors.js

@@ -0,0 +1,25 @@
+import { StudioCMSCoreError } from "../../errors.js";
+class StudioCMSRendererError extends StudioCMSCoreError {
+  name = "StudioCMS Renderer Error";
+}
+function prefixError(err, prefix) {
+  if (err?.message) {
+    try {
+      err.message = `${prefix}:
+${err.message}`;
+      return err;
+    } catch {
+    }
+  }
+  const wrappedError = new Error(`${prefix}${err ? `: ${err}` : ""}`);
+  try {
+    wrappedError.stack = err.stack;
+    wrappedError.cause = err;
+  } catch {
+  }
+  return wrappedError;
+}
+export {
+  StudioCMSRendererError,
+  prefixError
+};

package/dist/lib/renderer/markdoc-renderers/markdocHTML.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdocRenderer } from '../../../schemas/config/rendererConfig.js';
+export declare function renderHTML(): MarkdocRenderer;
+export default renderHTML;

package/dist/lib/renderer/markdoc-renderers/markdocHTML.js

@@ -0,0 +1,14 @@
+import Markdoc, {} from "@markdoc/markdoc";
+function renderHTML() {
+  return {
+    name: "html",
+    renderer: async (content) => {
+      return Markdoc.renderers.html(content);
+    }
+  };
+}
+var markdocHTML_default = renderHTML;
+export {
+  markdocHTML_default as default,
+  renderHTML
+};

package/dist/lib/renderer/markdoc-renderers/markdocReactStatic.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdocRenderer } from '../../../schemas/config/rendererConfig.js';
+export declare function renderReactStatic(): MarkdocRenderer;
+export default renderReactStatic;

package/dist/lib/renderer/markdoc-renderers/markdocReactStatic.js

@@ -0,0 +1,14 @@
+import Markdoc, {} from "@markdoc/markdoc";
+function renderReactStatic() {
+  return {
+    name: "react-static",
+    renderer: async (content) => {
+      return Markdoc.renderers.reactStatic(content);
+    }
+  };
+}
+var markdocReactStatic_default = renderReactStatic;
+export {
+  markdocReactStatic_default as default,
+  renderReactStatic
+};

package/dist/lib/renderer/markdoc.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Render a Markdown string into HTML using the Markdoc renderer
+ *
+ * Markdoc is a powerful, flexible, Markdown-based authoring framework. Built by Stripe.
+ * @see https://markdoc.dev/ for more info about markdoc.
+ *
+ * @param input - The Markdown string to render
+ * @returns The rendered HTML string
+ */
+export declare function renderMarkDoc(input: string): Promise<string>;
+export default renderMarkDoc;

package/dist/lib/renderer/markdoc.js

@@ -0,0 +1,28 @@
+import rendererConfig from "studiocms:renderer/config";
+import Markdoc, {} from "@markdoc/markdoc";
+import { StudioCMSRendererError } from "./errors.js";
+import renderHTML from "./markdoc-renderers/markdocHTML.js";
+import renderReactStatic from "./markdoc-renderers/markdocReactStatic.js";
+const {
+  markdocConfig: { argParse, transformConfig, renderType }
+} = rendererConfig;
+const renderers = [renderHTML(), renderReactStatic()];
+async function renderMarkDoc(input) {
+  const ast = Markdoc.parse(input, argParse);
+  const content = Markdoc.transform(ast, transformConfig);
+  const renderer = renderers.find((r) => r.name === renderType);
+  if (renderer) {
+    return renderer.renderer(content);
+  }
+  if (renderType !== "html" && renderType !== "react-static" && renderType.name && renderType.renderer) {
+    return renderType.renderer(content).catch((e) => {
+      throw new Error(`Failed to render content with custom renderer: [${renderType.name}]: ${e}`);
+    });
+  }
+  throw new StudioCMSRendererError(`Unknown MarkDoc render type: ${renderType}`);
+}
+var markdoc_default = renderMarkDoc;
+export {
+  markdoc_default as default,
+  renderMarkDoc
+};

package/dist/lib/renderer/mdx.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Render Astro MDX
+ *
+ * Renders Astro MDX content
+ *
+ * @param content - The content to render
+ * @returns The rendered content
+ */
+export declare function renderAstroMDX(content: string): Promise<string>;
+export default renderAstroMDX;

package/dist/lib/renderer/mdx.js

@@ -0,0 +1,37 @@
+import Config from "studiocms:renderer/config";
+import { evaluate } from "@mdx-js/mdx";
+import { createElement } from "react";
+import { renderToString } from "react-dom/server";
+import * as runtime from "react/jsx-runtime";
+import rehypeHighlight from "rehype-highlight";
+import remarkGfm from "remark-gfm";
+const {
+  mdxConfig: { recmaPlugins, rehypePlugins, remarkPlugins, remarkRehypeOptions }
+} = Config;
+const makeList = (included, userDefinedPlugins) => {
+  const Plugins = included;
+  if (userDefinedPlugins) {
+    for (const plugin of userDefinedPlugins) {
+      Plugins.push(plugin);
+    }
+  }
+  return Plugins;
+};
+const includedRemarkPlugins = [remarkGfm];
+const includedRehypePlugins = [rehypeHighlight];
+async function renderAstroMDX(content) {
+  const { default: MDXContent } = await evaluate(content, {
+    // biome-ignore lint/suspicious/noExplicitAny: react jsx-runtime is not typed
+    ...runtime,
+    remarkPlugins: makeList(includedRemarkPlugins, remarkPlugins),
+    rehypePlugins: makeList(includedRehypePlugins, rehypePlugins),
+    recmaPlugins,
+    remarkRehypeOptions
+  });
+  return renderToString(createElement(MDXContent));
+}
+var mdx_default = renderAstroMDX;
+export {
+  mdx_default as default,
+  renderAstroMDX
+};

package/dist/lib/renderer/runtime.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Imports components by their keys from the 'studiocms:markdown-remark/user-components' module.
+ *
+ * @param keys - An array of strings representing the keys of the components to import.
+ * @returns A promise that resolves to an object containing the imported components.
+ * @throws {MarkdownRemarkError} If any component fails to import, an error is thrown with a prefixed message.
+ */
+export declare function importComponentsKeys(): Promise<Record<string, any>>;

package/dist/lib/renderer/runtime.js

@@ -0,0 +1,30 @@
+import { componentKeys } from "studiocms:component-proxy";
+import * as mod from "studiocms:component-proxy";
+import { StudioCMSRendererError, prefixError } from "./errors.js";
+async function importComponentsKeys() {
+  const predefinedComponents = {};
+  for (const key of componentKeys) {
+    try {
+      predefinedComponents[key.toLowerCase()] = mod[key.toLowerCase()];
+    } catch (e) {
+      if (e instanceof Error) {
+        const newErr2 = prefixError(
+          e,
+          `Failed to import component "${key}" from Virtual Module "studiocms:component-proxy"`
+        );
+        console.error(newErr2);
+        throw new StudioCMSRendererError(newErr2.message, newErr2.stack);
+      }
+      const newErr = prefixError(
+        new Error("Unknown error"),
+        `Failed to import component "${key}" from Virtual Module "studiocms:component-proxy"`
+      );
+      console.error(newErr);
+      throw new StudioCMSRendererError(newErr.message, newErr.stack);
+    }
+  }
+  return predefinedComponents;
+}
+export {
+  importComponentsKeys
+};

package/dist/lib/renderer/shared.d.ts

@@ -0,0 +1,15 @@
+import type { Shared } from './types.js';
+export declare const symbol: symbol;
+/**
+ * A shared object that is either retrieved from the global scope using a symbol or
+ * initialized as a new object with a `markdownConfig` property.
+ *
+ * @constant
+ * @type {Shared}
+ *
+ * @remarks
+ * The `@ts-ignore` comments are used to suppress TypeScript errors related to the use of
+ * the global scope and assignment within expressions. The `biome-ignore` comment is used
+ * to suppress linting errors for the same reason.
+ */
+export declare const shared: Shared;

package/dist/lib/renderer/shared.js

@@ -0,0 +1,13 @@
+const symbol = Symbol.for("@studiocms/markdown-remark");
+const shared = (
+  // @ts-ignore
+  globalThis[symbol] || // @ts-ignore
+  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+  (globalThis[symbol] = {
+    markdownConfig: {}
+  })
+);
+export {
+  shared,
+  symbol
+};

package/dist/lib/renderer/studiocms.d.ts

@@ -0,0 +1,11 @@
+import type { SSRResult } from 'astro';
+/**
+ * Render StudioCMS Markdown content
+ *
+ * @param content - The StudioCMS Markdown content
+ * @param SSRResult - The SSR result Used to render the custom components
+ *
+ * @returns The rendered HTML
+ */
+export declare function renderStudioCMS(content: string, SSRResult: SSRResult): Promise<string>;
+export default renderStudioCMS;

package/dist/lib/renderer/studiocms.js

@@ -0,0 +1,22 @@
+import { createMarkdownProcessor } from "@studiocms/markdown-remark-processor";
+import { createComponentProxy, transformHTML } from "../../runtime/AstroComponentProxy.js";
+import { TransformToProcessor } from "../../schemas/index.js";
+import { importComponentsKeys } from "./runtime.js";
+import { shared } from "./shared.js";
+const studiocmsMarkdownExtended = TransformToProcessor.parse({ studiocms: shared.studiocms });
+const cachedProcessor = await createMarkdownProcessor({
+  ...shared.markdownConfig,
+  ...studiocmsMarkdownExtended
+});
+const _components = await importComponentsKeys();
+async function renderStudioCMS(content, SSRResult) {
+  const components = createComponentProxy(SSRResult, _components);
+  const code = (await cachedProcessor.render(content)).code;
+  const html = await transformHTML(code, components);
+  return html;
+}
+var studiocms_default = renderStudioCMS;
+export {
+  studiocms_default as default,
+  renderStudioCMS
+};

package/dist/lib/renderer/types.d.ts

@@ -0,0 +1,12 @@
+import type { StudioCMSConfigOptions } from '@studiocms/markdown-remark-processor';
+import type { AstroConfig } from 'astro';
+/**
+ * Interface representing shared configuration for markdown.
+ *
+ * @interface Shared
+ * @property {AstroConfig['markdown']} markdownConfig - The markdown configuration from AstroConfig.
+ */
+export interface Shared {
+    markdownConfig: AstroConfig['markdown'];
+    studiocms: StudioCMSConfigOptions;
+}

package/dist/lib/robots/core.d.ts

@@ -0,0 +1,24 @@
+import type { AstroIntegrationLogger } from 'astro';
+import type { RobotsConfig } from './types.js';
+/**
+ * Generates the content for the robots.txt file based on the provided configuration.
+ *
+ * @param {RobotsConfig} config - The configuration object for generating the robots.txt content.
+ * @param {string} siteMapHref - The URL of the sitemap.
+ * @param {AstroIntegrationLogger} logger - The logger instance for logging messages.
+ * @returns {string} The generated content for the robots.txt file.
+ *
+ * @throws Will throw an error if any policy is missing a required userAgent,
+ *         if both allow and disallow entries are missing or empty,
+ *         if crawlDelay is not a number or is out of the allowed range (0.1 to 60 seconds).
+ */
+export declare function generateContent(config: RobotsConfig, siteMapHref: string, logger: AstroIntegrationLogger): string;
+/**
+ * Prints information about the generation of the 'robots.txt' file.
+ *
+ * @param fileSize - The size of the generated 'robots.txt' file in KB.
+ * @param executionTime - The time taken to generate the 'robots.txt' file in milliseconds.
+ * @param logger - The logger instance used to log information.
+ * @param destDir - The destination directory where the 'robots.txt' file is created.
+ */
+export declare function printInfo(fileSize: number, executionTime: number, logger: AstroIntegrationLogger, destDir: string): void;

package/dist/lib/robots/core.js

@@ -0,0 +1,187 @@
+import path from "node:path";
+function validateHost(host, logger) {
+  const hostPattern = /^(?=.{1,253}$)(?:(?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$/;
+  if (typeof host !== "string") {
+    throwMsg("Host must be a string", "error", logger);
+  }
+  if (!hostPattern.test(host)) {
+    throwMsg("Host is invalid", "error", logger);
+  }
+}
+function generateHostContent(config, logger) {
+  let content = "";
+  if (config.host === true) {
+  } else if (config.host === false) {
+  } else if (typeof config.host === "number") {
+    validateHost(config.host, logger);
+  } else if (typeof config.host === "string" && config.host !== "localhost") {
+    validateHost(config.host, logger);
+    content += `Host: ${config.host}
+`;
+  }
+  return content;
+}
+function validateUrl(url, logger) {
+  const urlPattern = /^https?:\/\/[^\s/$.?#].[^\s]*\.(xml|txt|html|xml.gz|txt.gz|json|xhtml)$/i;
+  if (!urlPattern.test(url)) {
+    throwMsg("sitemap [URL is invalid or not a valid sitemap file.]", true, logger);
+  }
+}
+function generateSitemapContent(config, siteHref, logger) {
+  let content = "";
+  if (config.sitemap === true) {
+    content += `Sitemap: ${siteHref}sitemap-index.xml
+`;
+  } else if (typeof config.sitemap === "number") {
+    throwMsg("sitemap [URL is invalid or not a valid sitemap file.]", true, logger);
+  } else if (typeof config.sitemap === "string") {
+    validateUrl(config.sitemap, logger);
+    content += `Sitemap: ${config.sitemap}
+`;
+  } else if (Array.isArray(config.sitemap)) {
+    for (const url of config.sitemap) {
+      validateUrl(url, logger);
+      content += `Sitemap: ${url}
+`;
+    }
+  }
+  return content;
+}
+function throwMsg(msg, type, logger) {
+  const sentenceHead = "\x1B[1mRefer:\x1B[22m";
+  const failure = (message) => {
+    logger.info(`\x1B[31mFailure! [${message}]\x1B[39m`);
+  };
+  const warn = (message) => {
+    logger.warn(`Skipped! [${message}].`);
+  };
+  switch (type) {
+    case "warn":
+      warn(msg);
+      break;
+    case "error":
+      failure(msg);
+      throw new Error(`${msg}`);
+    case true:
+      failure(msg);
+      throw new Error(
+        `${msg}
+${sentenceHead}
+  Visit \x1B[4m${"https://developers.google.com/search/docs/crawling-indexing/robots/create-robots-txt#useful-robots.txt-rules"}\x1B[24m for instructions.`
+      );
+    default:
+      failure(msg);
+      throw new Error(
+        `${msg}
+${sentenceHead}
+  Visit \x1B[4m${"https://yandex.com/support/webmaster/controlling-robot/robots-txt.html#recommend"}\x1B[24m for instructions.`
+      );
+  }
+}
+function generateContent(config, siteMapHref, logger) {
+  let content = "";
+  for (const policy of config.policy ?? []) {
+    config?.policy?.forEach((policy2, index) => {
+      if (!policy2.userAgent) {
+        throwMsg(
+          `policy[${index}].userAgent [Required, one or more per group].
+${JSON.stringify(policy2, null, 2)}`,
+          !!policy2.userAgent,
+          logger
+        );
+      }
+      if (!policy2.allow && !policy2.disallow || policy2.allow?.length === 0 && policy2.disallow?.length === 0) {
+        throwMsg(
+          `policy[${index}] [At least one or more 'disallow' or 'allow' entries per rule].
+${JSON.stringify(policy2, null, 2)}`,
+          !policy2.allow && !policy2.disallow,
+          logger
+        );
+      }
+      if (policy2.crawlDelay && typeof policy2.crawlDelay !== "number") {
+        throwMsg(
+          `policy[${index}].crawlDelay [Must be number].
+${JSON.stringify(policy2, null, 2)}`,
+          false,
+          logger
+        );
+      } else if (policy2.crawlDelay !== void 0 && policy2?.crawlDelay < 0) {
+        throwMsg(
+          `policy[${index}].crawlDelay [Must be a positive number].
+${JSON.stringify(policy2, null, 2)}`,
+          false,
+          logger
+        );
+      } else if (policy2.crawlDelay !== void 0 && (policy2?.crawlDelay < 0.1 || policy2.crawlDelay > 60)) {
+        throwMsg(
+          `policy[${index}].crawlDelay [Must be between 0.1 and 60 seconds].
+${JSON.stringify(policy2, null, 2)}`,
+          false,
+          logger
+        );
+      }
+    });
+    if (policy.userAgent) {
+      const userAgents = Array.isArray(policy.userAgent) ? policy.userAgent : [policy.userAgent || "*"];
+      for (const userAgent of userAgents) {
+        if (userAgent) {
+          content += `User-agent: ${userAgent}
+`;
+        }
+      }
+    }
+    if (policy.allow) {
+      const allowPaths = Array.isArray(policy.allow) ? policy.allow : [policy.allow];
+      for (const path2 of allowPaths) {
+        content += `Allow: ${path2}
+`;
+      }
+    }
+    if (policy.disallow) {
+      const disallowPaths = Array.isArray(policy.disallow) ? policy.disallow : [policy.disallow];
+      for (const path2 of disallowPaths) {
+        content += `Disallow: ${path2}
+`;
+      }
+    }
+    if (policy.crawlDelay) {
+      content += `Crawl-delay: ${policy.crawlDelay}
+`;
+    }
+    if (policy.cleanParam) {
+      const cleanParams = Array.isArray(policy.cleanParam) ? policy.cleanParam : [policy.cleanParam];
+      for (const param of cleanParams) {
+        content += `Clean-param: ${param}
+`;
+      }
+    }
+    if (config.policy && policy !== config.policy[config.policy.length - 1]) {
+      content += "\n";
+    } else if (config.sitemap !== false) {
+      content += "\n# crawling rule(s) for above bots\n";
+    }
+  }
+  content += generateSitemapContent(config, siteMapHref, logger);
+  content += generateHostContent(config, logger);
+  return content;
+}
+function printInfo(fileSize, executionTime, logger, destDir) {
+  if (fileSize > 10) {
+    console.log(`
+\x1B[42m\x1B[30m generating 'robots.txt' file \x1B[39m\x1B[0m`);
+    const warnMsg = [
+      `
+\x1B[33m(!) Keep your 'robots.txt' file size under 10 KB for best crawling results.`,
+      "- To keep it low, only include directives that are necessary for your site.",
+      "- Remove rules for pages that no longer exist to avoid bloat.\x1B[0m\n"
+    ];
+    console.log(`${warnMsg.join("\n")}`);
+  }
+  logger.info(
+    `\`robots.txt\` (${fileSize}KB) created at \`${path.relative(process.cwd(), destDir)}\` in ${executionTime}ms`
+  );
+}
+export {
+  generateContent,
+  printInfo
+};

package/dist/lib/robots/index.d.ts

@@ -0,0 +1,11 @@
+import type { AstroIntegration } from 'astro';
+import type { RobotsConfig } from './types.js';
+/**
+ * **Robots.txt Integration**
+ *
+ * A simple integration to generate a `robots.txt` file for your Astro project.
+ *
+ * @param astroConfig Robots Configuration
+ * @returns AstroIntegration
+ */
+export default function createRobotsIntegration(options?: RobotsConfig): AstroIntegration;

package/dist/lib/robots/index.js

@@ -0,0 +1,47 @@
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { generateContent, printInfo } from "./core.js";
+import { getFileSizeInKilobytes, measureExecutionTime } from "./utils.js";
+const defaultConfig = {
+  sitemap: false,
+  host: false,
+  policy: [
+    {
+      userAgent: ["*"],
+      allow: ["/"],
+      disallow: ["/dashboard/", "/studiocms_api/"]
+    }
+  ]
+};
+function createRobotsIntegration(options) {
+  let astroConfig;
+  let finalSiteMapHref;
+  let executionTime;
+  const config = { ...defaultConfig, ...options };
+  return {
+    name: "studiocms/robotstxt",
+    hooks: {
+      "astro:config:setup": ({ config: cfg }) => {
+        astroConfig = cfg;
+      },
+      "astro:build:start": () => {
+        finalSiteMapHref = new URL(astroConfig.base, astroConfig.site).href;
+      },
+      "astro:build:done": async ({ dir, logger }) => {
+        executionTime = measureExecutionTime(() => {
+          fs.writeFileSync(
+            new URL("robots.txt", dir),
+            generateContent(config, finalSiteMapHref, logger),
+            "utf-8"
+          );
+        });
+        const fileSize = getFileSizeInKilobytes(new URL("robots.txt", dir));
+        const destDir = fileURLToPath(dir);
+        printInfo(fileSize, executionTime, logger, destDir);
+      }
+    }
+  };
+}
+export {
+  createRobotsIntegration as default
+};