studiocms 0.1.0-beta.10

package/dist/routes/sdk/fallback-list-pages.json.ts

@@ -0,0 +1,22 @@
+import studioCMS_SDK from 'studiocms:sdk/cache';
+import type { APIRoute } from 'astro';
+
+// export const prerender = true;
+
+export const GET: APIRoute = async (): Promise<Response> => {
+	const pages = await studioCMS_SDK.GET.pages();
+
+	const lastUpdated = new Date().toUTCString();
+
+	return new Response(
+		JSON.stringify({ lastUpdated, pages: pages.map((pageItem) => pageItem.data) }, null, 2),
+		{
+			headers: {
+				'Content-Type': 'application/json',
+				'ACCESS-CONTROL-ALLOW-ORIGIN': '*',
+				'Cache-Control': 'public, max-age=604800, immutable',
+				Date: lastUpdated,
+			},
+		}
+	);
+};

package/dist/routes/sdk/full-changelog.json.d.ts

@@ -0,0 +1,16 @@
+import type { APIRoute } from 'astro';
+import type { List } from 'mdast';
+export type Changelog = {
+    packageName: string;
+    versions: Version[];
+};
+export type Version = {
+    version: string;
+    changes: {
+        [key in SemverCategory]: List;
+    };
+    includes: Set<string>;
+};
+export declare const semverCategories: readonly ["major", "minor", "patch"];
+export type SemverCategory = (typeof semverCategories)[number];
+export declare const POST: APIRoute;

package/dist/routes/sdk/full-changelog.json.js

@@ -0,0 +1,170 @@
+import { StudioCMSRoutes } from "studiocms:lib";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { toString as ToString } from "mdast-util-to-string";
+import { visit } from "unist-util-visit";
+const semverCategories = ["major", "minor", "patch"];
+function parsePackageReference(str) {
+  const matches = str.match(/^([@/a-z0-9-]+)@([0-9.]+)$/);
+  if (!matches) return;
+  const [, packageName, version] = matches;
+  return { packageName, version };
+}
+const POST = async (context) => {
+  const Changelog = await fetch(
+    "https://raw.githubusercontent.com/withstudiocms/studiocms/refs/heads/main/packages/studiocms/CHANGELOG.md"
+  );
+  const ChangelogText = await Changelog.text();
+  if (ChangelogText) {
+    let handleNode2 = function(node) {
+      if (node.type === "heading") {
+        if (node.depth === 1) {
+          if (state !== "packageName") throw new Error("Unexpected h1");
+          changelog.packageName = ToString(node);
+          state = "version";
+          return;
+        }
+        if (node.depth === 2) {
+          if (state === "packageName") throw new Error("Unexpected h2");
+          version = {
+            version: ToString(node),
+            changes: {
+              major: { type: "list", children: [] },
+              minor: { type: "list", children: [] },
+              patch: { type: "list", children: [] }
+            },
+            includes: /* @__PURE__ */ new Set()
+          };
+          changelog.versions.push(version);
+          state = "semverCategory";
+          return;
+        }
+        if (node.depth === 3) {
+          if (state === "packageName" || state === "version") throw new Error("Unexpected h3");
+          semverCategory = (ToString(node).split(" ")[0] || "").toLowerCase();
+          if (!semverCategories.includes(semverCategory))
+            throw new Error(`Unexpected semver category: ${semverCategory}`);
+          state = "changes";
+          return;
+        }
+      }
+      if (node.type === "list") {
+        if (state !== "changes" || !version || !semverCategory) throw new Error("Unexpected list");
+        for (let listItemIdx = 0; listItemIdx < node.children.length; listItemIdx++) {
+          const listItem = node.children[listItemIdx];
+          if (!listItem) continue;
+          const lastChild = listItem.children[listItem.children.length - 1];
+          if (lastChild?.type === "list") {
+            const packageRefs = [];
+            lastChild.children.forEach((subListItem) => {
+              const text = ToString(subListItem);
+              if (parsePackageReference(text)) packageRefs.push(text);
+            });
+            if (packageRefs.length === lastChild.children.length) {
+              for (const packageRef of packageRefs) {
+                version.includes.add(packageRef);
+              }
+              listItem.children.pop();
+            }
+          }
+          const firstPara = listItem.children[0]?.type === "paragraph" ? listItem.children[0] : void 0;
+          if (firstPara) {
+            visit(firstPara, "text", (textNode) => {
+              textNode.value = textNode.value.replace(/(^[0-9a-f]{7,}: | \[[0-9a-f]{7,}\]$)/, "");
+            });
+            const firstParaText = ToString(firstPara);
+            if (firstParaText === "Updated dependencies") continue;
+            const packageRef = parsePackageReference(firstParaText);
+            if (packageRef) {
+              version.includes.add(firstParaText);
+              continue;
+            }
+            version.changes[semverCategory].children.push(listItem);
+          }
+        }
+        return;
+      }
+      throw new Error(`Unexpected node: ${JSON.stringify(node)}`);
+    };
+    var handleNode = handleNode2;
+    let markdown = ChangelogText;
+    markdown = markdown.replace(
+      /(?<=Thank[^.!]*? )@([a-z0-9-]+)(?=[\s,.!])/gi,
+      "[@$1](https://github.com/$1)"
+    );
+    const astStart = fromMarkdown(markdown);
+    const changelog = {
+      packageName: "",
+      versions: []
+    };
+    let state = "packageName";
+    let version;
+    let semverCategory;
+    astStart.children.forEach((node) => {
+      handleNode2(node);
+    });
+    const ToProcess = changelog;
+    const output = [];
+    const astEnd = {
+      type: "root",
+      children: []
+    };
+    for (const version2 of ToProcess.versions) {
+      const versionChanges = { type: "list", children: [] };
+      for (const semverCategory2 of semverCategories) {
+        for (const listItem of version2.changes[semverCategory2].children) {
+          versionChanges.children.push(listItem);
+        }
+      }
+      if (version2.includes.size) {
+        versionChanges.children.push({
+          type: "listItem",
+          children: [
+            {
+              type: "paragraph",
+              children: [{ type: "text", value: `Includes: ${[...version2.includes].join(", ")} ` }]
+            }
+          ]
+        });
+      }
+      if (!versionChanges.children.length) continue;
+      astEnd.children.push({
+        type: "heading",
+        depth: 2,
+        children: [{ type: "text", value: version2.version }]
+      });
+      astEnd.children.push(versionChanges);
+    }
+    output.push(toMarkdown(astEnd, { bullet: "-" }));
+    const markdownString = output.join("\n");
+    const currentRequestJson = await context.request.json();
+    const currentURLOrigin = currentRequestJson.currentURLOrigin;
+    const partialUrl = new URL(StudioCMSRoutes.endpointLinks.partials.render, currentURLOrigin);
+    const partialResponse = await fetch(partialUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ content: markdownString })
+    });
+    const contentRendered = await partialResponse.text();
+    return new Response(JSON.stringify({ success: true, changelog: contentRendered }), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        Date: (/* @__PURE__ */ new Date()).toUTCString()
+      }
+    });
+  }
+  return new Response(JSON.stringify({ success: false, error: "Error fetching changelog" }), {
+    status: 500,
+    headers: {
+      "Content-Type": "application/json",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+export {
+  POST,
+  semverCategories
+};

package/dist/routes/sdk/full-changelog.json.ts

@@ -0,0 +1,224 @@
+import { StudioCMSRoutes } from 'studiocms:lib';
+import type { APIContext, APIRoute } from 'astro';
+import type { List, Root } from 'mdast';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { toMarkdown } from 'mdast-util-to-markdown';
+import { toString as ToString } from 'mdast-util-to-string';
+import { visit } from 'unist-util-visit';
+
+export type Changelog = {
+	packageName: string;
+	versions: Version[];
+};
+
+export type Version = {
+	version: string;
+	changes: { [key in SemverCategory]: List };
+	includes: Set<string>;
+};
+
+export const semverCategories = ['major', 'minor', 'patch'] as const;
+export type SemverCategory = (typeof semverCategories)[number];
+
+function parsePackageReference(str: string) {
+	const matches = str.match(/^([@/a-z0-9-]+)@([0-9.]+)$/);
+	if (!matches) return;
+	const [, packageName, version] = matches;
+	return { packageName, version };
+}
+
+export const POST: APIRoute = async (context: APIContext) => {
+	const Changelog = await fetch(
+		'https://raw.githubusercontent.com/withstudiocms/studiocms/refs/heads/main/packages/studiocms/CHANGELOG.md'
+	);
+
+	const ChangelogText = await Changelog.text();
+
+	if (ChangelogText) {
+		let markdown = ChangelogText;
+
+		// Convert GitHub usernames in "Thanks ..." sentences to links
+		markdown = markdown.replace(
+			/(?<=Thank[^.!]*? )@([a-z0-9-]+)(?=[\s,.!])/gi,
+			'[@$1](https://github.com/$1)'
+		);
+
+		const astStart = fromMarkdown(markdown);
+
+		const changelog: Changelog = {
+			packageName: '',
+			versions: [],
+		};
+
+		type ParserState = 'packageName' | 'version' | 'semverCategory' | 'changes';
+		let state: ParserState = 'packageName';
+		let version: Version | undefined;
+		let semverCategory: SemverCategory | undefined;
+
+		function handleNode(node: ReturnType<typeof fromMarkdown>['children'][number]) {
+			if (node.type === 'heading') {
+				if (node.depth === 1) {
+					if (state !== 'packageName') throw new Error('Unexpected h1');
+					changelog.packageName = ToString(node);
+					state = 'version';
+					return;
+				}
+				if (node.depth === 2) {
+					if (state === 'packageName') throw new Error('Unexpected h2');
+					version = {
+						version: ToString(node),
+						changes: {
+							major: { type: 'list', children: [] },
+							minor: { type: 'list', children: [] },
+							patch: { type: 'list', children: [] },
+						},
+						includes: new Set<string>(),
+					};
+					changelog.versions.push(version);
+					state = 'semverCategory';
+					return;
+				}
+				if (node.depth === 3) {
+					if (state === 'packageName' || state === 'version') throw new Error('Unexpected h3');
+					semverCategory = (ToString(node).split(' ')[0] || '').toLowerCase() as SemverCategory;
+					if (!semverCategories.includes(semverCategory))
+						throw new Error(`Unexpected semver category: ${semverCategory}`);
+					state = 'changes';
+					return;
+				}
+			}
+			if (node.type === 'list') {
+				if (state !== 'changes' || !version || !semverCategory) throw new Error('Unexpected list');
+				// Go through list items
+				for (let listItemIdx = 0; listItemIdx < node.children.length; listItemIdx++) {
+					const listItem = node.children[listItemIdx];
+					if (!listItem) continue;
+
+					// Check if the current list item ends with a nested sublist that consists
+					// of items matching the pattern `<some-package-name>@<version>`
+					const lastChild = listItem.children[listItem.children.length - 1];
+					if (lastChild?.type === 'list') {
+						const packageRefs: string[] = [];
+						// biome-ignore lint/complexity/noForEach: <explanation>
+						lastChild.children.forEach((subListItem) => {
+							const text = ToString(subListItem);
+							if (parsePackageReference(text)) packageRefs.push(text);
+						});
+						if (packageRefs.length === lastChild.children.length) {
+							// If so, add the packages to `includes`
+							for (const packageRef of packageRefs) {
+								version.includes.add(packageRef);
+							}
+							// Remove the sub-list from the list item
+							listItem.children.pop();
+						}
+					}
+
+					const firstPara =
+						listItem.children[0]?.type === 'paragraph' ? listItem.children[0] : undefined;
+					if (firstPara) {
+						// Remove IDs like `bfed62a: ...` or `... [85dbab8]` from the first paragraph
+						visit(firstPara, 'text', (textNode) => {
+							textNode.value = textNode.value.replace(/(^[0-9a-f]{7,}: | \[[0-9a-f]{7,}\]$)/, '');
+						});
+						// Skip list items that only contain the text `Updated dependencies`
+						const firstParaText = ToString(firstPara);
+						if (firstParaText === 'Updated dependencies') continue;
+						// If the list item is a package reference, add it to `includes` instead
+						const packageRef = parsePackageReference(firstParaText);
+						if (packageRef) {
+							version.includes.add(firstParaText);
+							continue;
+						}
+						// Add the list item to the changes
+						version.changes[semverCategory].children.push(listItem);
+					}
+				}
+				return;
+			}
+			throw new Error(`Unexpected node: ${JSON.stringify(node)}`);
+		}
+
+		// biome-ignore lint/complexity/noForEach: <explanation>
+		astStart.children.forEach((node) => {
+			handleNode(node);
+		});
+
+		const ToProcess = changelog;
+
+		const output: string[] = [];
+
+		const astEnd: Root = {
+			type: 'root',
+			children: [],
+		};
+
+		for (const version of ToProcess.versions) {
+			const versionChanges: List = { type: 'list', children: [] };
+
+			for (const semverCategory of semverCategories) {
+				for (const listItem of version.changes[semverCategory].children) {
+					versionChanges.children.push(listItem);
+				}
+			}
+
+			if (version.includes.size) {
+				versionChanges.children.push({
+					type: 'listItem',
+					children: [
+						{
+							type: 'paragraph',
+							children: [{ type: 'text', value: `Includes: ${[...version.includes].join(', ')} ` }],
+						},
+					],
+				});
+			}
+
+			if (!versionChanges.children.length) continue;
+
+			astEnd.children.push({
+				type: 'heading',
+				depth: 2,
+				children: [{ type: 'text', value: version.version }],
+			});
+
+			astEnd.children.push(versionChanges);
+		}
+
+		output.push(toMarkdown(astEnd, { bullet: '-' }));
+
+		const markdownString = output.join('\n');
+
+		const currentRequestJson = await context.request.json();
+
+		const currentURLOrigin = currentRequestJson.currentURLOrigin;
+
+		const partialUrl = new URL(StudioCMSRoutes.endpointLinks.partials.render, currentURLOrigin);
+
+		const partialResponse = await fetch(partialUrl, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify({ content: markdownString }),
+		});
+
+		const contentRendered = await partialResponse.text();
+
+		return new Response(JSON.stringify({ success: true, changelog: contentRendered }), {
+			status: 200,
+			headers: {
+				'Content-Type': 'application/json',
+				Date: new Date().toUTCString(),
+			},
+		});
+	}
+
+	return new Response(JSON.stringify({ success: false, error: 'Error fetching changelog' }), {
+		status: 500,
+		headers: {
+			'Content-Type': 'application/json',
+			Date: new Date().toUTCString(),
+		},
+	});
+};

package/dist/routes/sdk/list-pages.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/sdk/list-pages.js

@@ -0,0 +1,34 @@
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+const GET = async () => {
+  const pages = await studioCMS_SDK_Cache.GET.pages();
+  const lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  return new Response(JSON.stringify({ lastUpdated, pages }, null, 2), {
+    headers: {
+      "Content-Type": "application/json",
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*",
+      Date: lastUpdated
+    }
+  });
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed"
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/sdk/update-latest-version-cache.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/sdk/update-latest-version-cache.js

@@ -0,0 +1,41 @@
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+const GET = async () => {
+  const latestVersion = await studioCMS_SDK_Cache.UPDATE.latestVersion().catch((err) => {
+    return new Response(JSON.stringify({ success: false, error: err }), {
+      status: 500,
+      headers: {
+        "Content-Type": "application/json",
+        Date: (/* @__PURE__ */ new Date()).toUTCString()
+      }
+    });
+  });
+  return new Response(JSON.stringify({ success: true, latestVersion }), {
+    status: 200,
+    headers: {
+      "Content-Type": "application/json",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed"
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/runtime/AstroComponentProxy.d.ts

@@ -0,0 +1,29 @@
+import type { SSRResult } from 'astro';
+import { type SanitizeOptions } from 'ultrahtml/transformers/sanitize';
+/**
+ * Creates a proxy for components that can either be strings or functions.
+ * If the component is a string, it is directly assigned to the proxy.
+ * If the component is a function, it is wrapped in an async function that
+ * processes the props and children before rendering.
+ *
+ * @param result - The result object used for rendering JSX.
+ * @param _components - An optional record of components to be proxied. Defaults to an empty object.
+ * @returns A record of proxied components.
+ */
+export declare function createComponentProxy(result: SSRResult, _components?: Record<string, any>): Record<string, any>;
+/**
+ * Removes leading indentation from a multi-line string.
+ *
+ * @param str - The string from which to remove leading indentation.
+ * @returns The dedented string.
+ */
+export declare function dedent(str: string): string;
+/**
+ * Transforms the provided HTML string by applying sanitization and component swapping.
+ *
+ * @param html - The HTML string to be transformed.
+ * @param components - A record of components to be swapped within the HTML. The keys are component names and the values are the corresponding component implementations.
+ * @param sanitizeOpts - Optional sanitization options to be applied to the HTML.
+ * @returns A promise that resolves to the transformed HTML string.
+ */
+export declare function transformHTML(html: string, components: Record<string, any>, sanitizeOpts?: SanitizeOptions): Promise<string>;

package/dist/runtime/AstroComponentProxy.js

@@ -0,0 +1,47 @@
+import { jsx } from "astro/jsx-runtime";
+import { renderJSX } from "astro/runtime/server/jsx.js";
+import { __unsafeHTML, transform } from "ultrahtml";
+import sanitize, {} from "ultrahtml/transformers/sanitize";
+import swap from "ultrahtml/transformers/swap";
+import { decode } from "./decoder/index.js";
+function createComponentProxy(result, _components = {}) {
+  const components = {};
+  for (const [key, value] of Object.entries(_components)) {
+    if (typeof value === "string") {
+      components[key.toLowerCase()] = value;
+    } else {
+      components[key.toLowerCase()] = async (props, children) => {
+        if (key === "codeblock" || key === "codespan") {
+          props.code = decode(JSON.parse(`"${props.code}"`));
+        }
+        const output = await renderJSX(
+          result,
+          jsx(value, { ...props, "set:html": children.value })
+        );
+        return __unsafeHTML(output);
+      };
+    }
+  }
+  return components;
+}
+function getIndent(ln) {
+  if (ln.trimStart() === ln) return "";
+  return ln.slice(0, ln.length - ln.trimStart().length);
+}
+function dedent(str) {
+  const lns = str.replace(/^[\r\n]+/, "").split("\n");
+  let indent = getIndent(lns[0]);
+  if (indent.length === 0 && lns.length > 1) {
+    indent = getIndent(lns[1]);
+  }
+  if (indent.length === 0) return lns.join("\n");
+  return lns.map((ln) => ln.startsWith(indent) ? ln.slice(indent.length) : ln).join("\n");
+}
+async function transformHTML(html, components, sanitizeOpts) {
+  return await transform(dedent(html), [sanitize(sanitizeOpts), swap(components)]);
+}
+export {
+  createComponentProxy,
+  dedent,
+  transformHTML
+};

package/dist/runtime/decoder/decode-codepoint.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
+ */
+export declare const fromCodePoint: (...codePoints: number[]) => string;
+/**
+ * Replace the given code point with a replacement character if it is a
+ * surrogate or is outside the valid range. Otherwise return the code
+ * point unchanged.
+ */
+export declare function replaceCodePoint(codePoint: number): number;
+/**
+ * Replace the code point if relevant, then convert it to a string.
+ *
+ * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.
+ * @param codePoint The code point to decode.
+ * @returns The decoded code point.
+ */
+export declare function decodeCodePoint(codePoint: number): string;

package/dist/runtime/decoder/decode-codepoint.js

@@ -0,0 +1,58 @@
+const decodeMap = /* @__PURE__ */ new Map([
+  [0, 65533],
+  // C1 Unicode control character reference replacements
+  [128, 8364],
+  [130, 8218],
+  [131, 402],
+  [132, 8222],
+  [133, 8230],
+  [134, 8224],
+  [135, 8225],
+  [136, 710],
+  [137, 8240],
+  [138, 352],
+  [139, 8249],
+  [140, 338],
+  [142, 381],
+  [145, 8216],
+  [146, 8217],
+  [147, 8220],
+  [148, 8221],
+  [149, 8226],
+  [150, 8211],
+  [151, 8212],
+  [152, 732],
+  [153, 8482],
+  [154, 353],
+  [155, 8250],
+  [156, 339],
+  [158, 382],
+  [159, 376]
+]);
+const fromCodePoint = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
+  String.fromCodePoint ?? ((codePoint) => {
+    let output = "";
+    if (codePoint > 65535) {
+      codePoint -= 65536;
+      output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
+      codePoint = 56320 | codePoint & 1023;
+    }
+    output += String.fromCharCode(codePoint);
+    return output;
+  })
+);
+function replaceCodePoint(codePoint) {
+  if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) {
+    return 65533;
+  }
+  return decodeMap.get(codePoint) ?? codePoint;
+}
+function decodeCodePoint(codePoint) {
+  return fromCodePoint(replaceCodePoint(codePoint));
+}
+export {
+  decodeCodePoint,
+  fromCodePoint,
+  replaceCodePoint
+};

package/dist/runtime/decoder/decode-data-html.d.ts

@@ -0,0 +1 @@
+export declare const htmlDecodeTree: Uint16Array;