Upgrade

Let's hope it doesn't explode ❤️

Author: meruune

.astro/settings.json

@@ -0,0 +1,5 @@
+{
+	"_variables": {
+		"lastUpdateCheck": 1753692852857
+	}
+}

.astro/types.d.ts

@@ -0,0 +1 @@
+/// <reference types="astro/client" />

.github/workflows/build.yml

@@ -17,7 +17,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16.x]
+        node-version: [23.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:

astro.config.ts

@@ -2,6 +2,7 @@ import { defineConfig } from 'astro/config';
 import preact from '@astrojs/preact';
 import react from '@astrojs/react';
 import sitemap from "@astrojs/sitemap";
+import mdx from '@astrojs/mdx';
 import { h } from 'hastscript';
 import rehypeSlugifyCounter from 'rehype-slugify-counter';
 
@@ -10,7 +11,7 @@ const AnchorLinkIcon = h('svg', {
   height: 16,
   version: 1.1,
   viewBox: '0 0 16 16',
-  xlmns: 'http://www.w3.org/2000/svg'
+  xmlns: 'http://www.w3.org/2000/svg'
 }, h('path', {
   fillRule: 'evenodd',
   fill: 'currentcolor',
@@ -19,13 +20,27 @@ const AnchorLinkIcon = h('svg', {
 
 export default defineConfig({
   site: 'https://docs.k2vr.tech',
-  integrations: [preact(), react(), sitemap()],
+  integrations: [preact(), react(), sitemap(), mdx()],
+  legacy: {
+    astroFlavoredMarkdown: true
+  },
+  experimental: {
+    contentCollectionCache: false
+  },
+  vite: {
+    resolve: {
+      alias: {
+        '~': '/src',
+        '@components': '/src/components',
+        '@layouts': '/src/layouts',
+        '@icons': '/src/icons'
+      }
+    }
+  },
   markdown: {
-    mode: 'mdx',
     syntaxHighlight: 'shiki',
+    remarkPlugins: ['remark-gfm', 'remark-smartypants'],
     rehypePlugins: [
-    // These are here because setting custom plugins disables the default plugins
-    'remark-smartypants', 'remark-gfm',
     // This generates a set of IDs and numeric counters for headers
     rehypeSlugifyCounter,
     // This adds said IDs to headings
@@ -42,7 +57,7 @@ export default defineConfig({
       }, AnchorLinkIcon)]
     }]],
     shikiConfig: {
-      theme: '../../../../../../src/srcery', // YES I KNOW THIS IS HACKY AS FUCK, IDC LOL
+      theme: 'dark-plus',
       wrap: true
     }
   }

convert-markdown.mjs

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function convertMarkdownFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  
+  // Normalize line endings
+  const normalizedContent = content.replace(/\r\n/g, '\n');
+  
+  // Parse frontmatter
+  const frontmatterMatch = normalizedContent.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    console.log(`No frontmatter found in ${filePath}`);
+    return false;
+  }
+  
+  const [, frontmatter, markdownContent] = frontmatterMatch;
+  
+  // Check if it has setup frontmatter
+  const setupMatch = frontmatter.match(/setup:\s*\|\s*\n([\s\S]*?)(?=\n\w+:|$)/);
+  if (!setupMatch) {
+    console.log(`No setup found in ${filePath}`);
+    return false;
+  }
+  
+  const setupCode = setupMatch[1].trim();
+  
+  // Remove setup from frontmatter
+  const newFrontmatter = frontmatter.replace(/setup:\s*\|\s*\n([\s\S]*?)(?=\n\w+:|$)/, '').trim();
+  
+  // Create new content with imports at the top
+  const newContent = `---\n${newFrontmatter}\n---\n${setupCode}\n\n${markdownContent}`;
+  
+  // Write to .mdx file
+  const mdxPath = filePath.replace('.md', '.mdx');
+  fs.writeFileSync(mdxPath, newContent);
+  
+  // Remove old .md file
+  fs.unlinkSync(filePath);
+  
+  console.log(`Converted ${filePath} to ${mdxPath}`);
+  return true;
+}
+
+function processDirectory(dirPath) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    
+    if (entry.isDirectory()) {
+      processDirectory(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      convertMarkdownFile(fullPath);
+    }
+  }
+}
+
+// Process src/pages directory
+const pagesDir = path.join(__dirname, 'src', 'pages');
+processDirectory(pagesDir);
+
+console.log('Conversion complete!');

fix-mdx.mjs

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function fixMdxFile(filePath) {
+  let content = fs.readFileSync(filePath, 'utf-8');
+  let changed = false;
+  
+  // Fix LinkButton tags specifically - they're case sensitive
+  content = content.replace(/<linkButton([^>]*?)\s*\/\s*>([^<]+)<\/LinkButton>/gi, (match, attributes, innerContent) => {
+    changed = true;
+    return `<LinkButton${attributes}>${innerContent}</LinkButton>`;
+  });
+  
+  // Fix self-closing tags that shouldn't be self-closing
+  const containerTags = ['CardTip', 'CardWarning', 'CardInfo', 'CardError', 'CardHelp', 'LinkButton', 'DownloadCard'];
+  for (const tag of containerTags) {
+    // Fix cases like <CardTip />content</CardTip>
+    const regex = new RegExp(`<${tag}([^>]*?)\\s*\\/\\s*>([^<]+)<\\/${tag}>`, 'gi');
+    content = content.replace(regex, (match, attributes, innerContent) => {
+      changed = true;
+      return `<${tag}${attributes}>${innerContent}</${tag}>`;
+    });
+  }
+  
+  // Fix self-closing tags
+  const selfClosingTags = ['br', 'img', 'hr', 'input', 'meta', 'link'];
+  for (const tag of selfClosingTags) {
+    const regex = new RegExp(`<${tag}([^>]*?)>(?!</)`, 'gi');
+    const newContent = content.replace(regex, (match, attributes) => {
+      if (!attributes.trim().endsWith('/')) {
+        changed = true;
+        return `<${tag}${attributes} />`;
+      }
+      return match;
+    });
+    content = newContent;
+  }
+  
+  // Fix unclosed br tags specifically
+  content = content.replace(/<br>/gi, '<br />');
+  if (content !== fs.readFileSync(filePath, 'utf-8')) changed = true;
+  
+  if (changed) {
+    fs.writeFileSync(filePath, content);
+    console.log(`Fixed ${filePath}`);
+  }
+}
+
+function processDirectory(dirPath) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    
+    if (entry.isDirectory()) {
+      processDirectory(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith('.mdx')) {
+      fixMdxFile(fullPath);
+    }
+  }
+}
+
+// Process src/pages directory
+const pagesDir = path.join(__dirname, 'src', 'pages');
+processDirectory(pagesDir);
+
+console.log('MDX fixes complete!');

fix-mismatched.mjs

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function findMismatchedTags(content) {
+  const matches = [];
+  const tagRegex = /<(Card\w+)[^>]*>/g;
+  const closeTagRegex = /<\/(Card\w+)>/g;
+  
+  let match;
+  const openTags = [];
+  
+  // Find all opening tags
+  while ((match = tagRegex.exec(content)) !== null) {
+    openTags.push({
+      tag: match[1],
+      index: match.index,
+      full: match[0]
+    });
+  }
+  
+  // Find all closing tags
+  const closeTags = [];
+  while ((match = closeTagRegex.exec(content)) !== null) {
+    closeTags.push({
+      tag: match[1],
+      index: match.index,
+      full: match[0]
+    });
+  }
+  
+  // Check for mismatches
+  for (let i = 0; i < openTags.length && i < closeTags.length; i++) {
+    if (openTags[i].tag !== closeTags[i].tag) {
+      matches.push({
+        openTag: openTags[i],
+        closeTag: closeTags[i]
+      });
+    }
+  }
+  
+  return matches;
+}
+
+function fixMismatchedTags(filePath) {
+  let content = fs.readFileSync(filePath, 'utf-8');
+  const mismatches = findMismatchedTags(content);
+  
+  if (mismatches.length > 0) {
+    console.log(`Found ${mismatches.length} mismatched tags in ${filePath}`);
+    
+    // Fix from the end to preserve indices
+    for (let i = mismatches.length - 1; i >= 0; i--) {
+      const mismatch = mismatches[i];
+      const correctCloseTag = `</${mismatch.openTag.tag}>`;
+      
+      content = content.substring(0, mismatch.closeTag.index) + 
+                correctCloseTag + 
+                content.substring(mismatch.closeTag.index + mismatch.closeTag.full.length);
+      
+      console.log(`Fixed: ${mismatch.openTag.tag} -> ${mismatch.closeTag.tag} to ${mismatch.openTag.tag}`);
+    }
+    
+    fs.writeFileSync(filePath, content);
+    return true;
+  }
+  
+  return false;
+}
+
+function processDirectory(dirPath) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    
+    if (entry.isDirectory()) {
+      processDirectory(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith('.mdx')) {
+      fixMismatchedTags(fullPath);
+    }
+  }
+}
+
+// Process src/pages directory
+const pagesDir = path.join(__dirname, 'src', 'pages');
+processDirectory(pagesDir);
+
+console.log('Mismatch fixes complete!');