@useavalon/avalon 0.1.11 → 0.1.13

package/src/core/content/mdx-processor.ts

@@ -1,46 +1,46 @@
-import { extname } from 'node:path';
-import { readFile } from 'node:fs/promises';
-import { h } from 'preact';
-import { marked } from 'marked';
-import type { RoutePageModule } from '../../schemas/routing.ts';
-
-/**
- * Server-side MDX processor for handling MDX files in the routing system
- */
-export class MDXProcessor {
-	/**
-	 * Process an MDX file and return a valid page module
-	 */
-	async processMDXFile(filePath: string): Promise<RoutePageModule> {
-		try {
-			// Read the MDX file content
-			const content = await readFile(filePath, 'utf-8');
-
-			// Process markdown content using marked library
-			const component = () => {
-				const htmlContent = marked(content);
-				return h('div', {
-					dangerouslySetInnerHTML: { __html: htmlContent },
-				});
-			};
-
-			// Return a module-like object that matches RoutePageModule interface
-			return {
-				default: component,
-				// Add any other required exports
-			};
-		} catch (error) {
-			throw new Error(
-				`Failed to process MDX file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-			);
-		}
-	}
-
-	/**
-	 * Check if a file is an MDX file
-	 */
-	static isMDXFile(filePath: string): boolean {
-		const ext = extname(filePath);
-		return ext === '.mdx' || ext === '.md';
-	}
-}
+import { extname } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { h } from 'preact';
+import { marked } from 'marked';
+import type { RoutePageModule } from '../../schemas/routing.ts';
+
+/**
+ * Server-side MDX processor for handling MDX files in the routing system
+ */
+export class MDXProcessor {
+	/**
+	 * Process an MDX file and return a valid page module
+	 */
+	async processMDXFile(filePath: string): Promise<RoutePageModule> {
+		try {
+			// Read the MDX file content
+			const content = await readFile(filePath, 'utf-8');
+
+			// Process markdown content using marked library
+			const component = () => {
+				const htmlContent = marked(content);
+				return h('div', {
+					dangerouslySetInnerHTML: { __html: htmlContent },
+				});
+			};
+
+			// Return a module-like object that matches RoutePageModule interface
+			return {
+				default: component,
+				// Add any other required exports
+			};
+		} catch (error) {
+			throw new Error(
+				`Failed to process MDX file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+			);
+		}
+	}
+
+	/**
+	 * Check if a file is an MDX file
+	 */
+	static isMDXFile(filePath: string): boolean {
+		const ext = extname(filePath);
+		return ext === '.mdx' || ext === '.md';
+	}
+}

package/src/core/integrations/index.ts

@@ -1,19 +1,19 @@
-/**
- * Integration system exports
- * Central export point for all integration-related functionality
- */
-
-// Registry
-export { IntegrationRegistry, registry } from "./registry.ts";
-
-// Loader
-export {
-  loadIntegration,
-  detectAndLoadIntegration,
-  detectFrameworkFromPath,
-  detectFrameworkFromContent,
-  preloadIntegrations,
-  getLoadedIntegrations,
-  clearIntegrationCache,
-  isIntegrationLoaded,
-} from "./loader.ts";
+/**
+ * Integration system exports
+ * Central export point for all integration-related functionality
+ */
+
+// Registry
+export { IntegrationRegistry, registry } from "./registry.ts";
+
+// Loader
+export {
+  loadIntegration,
+  detectAndLoadIntegration,
+  detectFrameworkFromPath,
+  detectFrameworkFromContent,
+  preloadIntegrations,
+  getLoadedIntegrations,
+  clearIntegrationCache,
+  isIntegrationLoaded,
+} from "./loader.ts";

package/src/core/integrations/loader.ts

@@ -1,125 +1,125 @@
-import { registry } from "./registry.ts";
-import type { Integration } from "@useavalon/core";
-
-/**
- * Cache for loaded integrations to avoid repeated dynamic imports
- */
-const integrationCache = new Map<string, Integration>();
-
-/**
- * Load an integration by name, using cache if available
- */
-export async function loadIntegration(framework: string): Promise<Integration> {
-  // Check cache first
-  if (integrationCache.has(framework)) {
-    return integrationCache.get(framework)!;
-  }
-
-  // Load from registry (which handles dynamic imports)
-  const integration = await registry.load(framework);
-  
-  // Cache the loaded integration
-  integrationCache.set(framework, integration);
-  
-  return integration;
-}
-
-/**
- * Detect framework from file path and load the appropriate integration
- */
-export async function detectAndLoadIntegration(src: string): Promise<Integration> {
-  const framework = detectFrameworkFromPath(src);
-  return await loadIntegration(framework);
-}
-
-/**
- * Detect framework from file path based on extension and naming conventions
- */
-export function detectFrameworkFromPath(src: string): string {
-  // Vue files
-  if (src.endsWith(".vue")) {
-    return "vue";
-  }
-  
-  // Svelte files
-  if (src.endsWith(".svelte")) {
-    return "svelte";
-  }
-  
-  // Solid files (convention: .solid.tsx or .solid.jsx)
-  if (src.includes(".solid.")) {
-    return "solid";
-  }
-  
-  // Qwik files (convention: .qwik.tsx or .qwik.jsx)
-  if (src.includes(".qwik.")) {
-    return "qwik";
-  }
-  
-  // Default to Preact for .tsx and .jsx files
-  return "preact";
-}
-
-/**
- * Detect framework from file content by analyzing imports and patterns
- */
-export function detectFrameworkFromContent(
-  src: string,
-  content?: string
-): string {
-  // First try path-based detection
-  const pathFramework = detectFrameworkFromPath(src);
-  
-  // If we have a definitive answer from path, use it
-  if (pathFramework !== "preact" || !content) {
-    return pathFramework;
-  }
-  
-  // For .tsx/.jsx files, analyze content to distinguish between Preact and Solid
-  if (content.includes("solid-js")) {
-    return "solid";
-  }
-  
-  if (content.includes("@builder.io/qwik")) {
-    return "qwik";
-  }
-  
-  if (content.includes("preact")) {
-    return "preact";
-  }
-  
-  // Default to Preact
-  return "preact";
-}
-
-/**
- * Preload integrations for the given frameworks
- * Useful for warming up the cache during build or startup
- */
-export async function preloadIntegrations(frameworks: string[]): Promise<void> {
-  await Promise.all(
-    frameworks.map(framework => loadIntegration(framework))
-  );
-}
-
-/**
- * Get all currently loaded integrations
- */
-export function getLoadedIntegrations(): Integration[] {
-  return Array.from(integrationCache.values());
-}
-
-/**
- * Clear the integration cache
- * Useful for testing or hot module replacement
- */
-export function clearIntegrationCache(): void {
-  integrationCache.clear();
-}
-
-/**
- * Check if an integration is loaded in cache
- */
-export function isIntegrationLoaded(framework: string): boolean {
-  return integrationCache.has(framework);
-}
+import { registry } from "./registry.ts";
+import type { Integration } from "@useavalon/core";
+
+/**
+ * Cache for loaded integrations to avoid repeated dynamic imports
+ */
+const integrationCache = new Map<string, Integration>();
+
+/**
+ * Load an integration by name, using cache if available
+ */
+export async function loadIntegration(framework: string): Promise<Integration> {
+  // Check cache first
+  if (integrationCache.has(framework)) {
+    return integrationCache.get(framework)!;
+  }
+
+  // Load from registry (which handles dynamic imports)
+  const integration = await registry.load(framework);
+  
+  // Cache the loaded integration
+  integrationCache.set(framework, integration);
+  
+  return integration;
+}
+
+/**
+ * Detect framework from file path and load the appropriate integration
+ */
+export async function detectAndLoadIntegration(src: string): Promise<Integration> {
+  const framework = detectFrameworkFromPath(src);
+  return await loadIntegration(framework);
+}
+
+/**
+ * Detect framework from file path based on extension and naming conventions
+ */
+export function detectFrameworkFromPath(src: string): string {
+  // Vue files
+  if (src.endsWith(".vue")) {
+    return "vue";
+  }
+  
+  // Svelte files
+  if (src.endsWith(".svelte")) {
+    return "svelte";
+  }
+  
+  // Solid files (convention: .solid.tsx or .solid.jsx)
+  if (src.includes(".solid.")) {
+    return "solid";
+  }
+  
+  // Qwik files (convention: .qwik.tsx or .qwik.jsx)
+  if (src.includes(".qwik.")) {
+    return "qwik";
+  }
+  
+  // Default to Preact for .tsx and .jsx files
+  return "preact";
+}
+
+/**
+ * Detect framework from file content by analyzing imports and patterns
+ */
+export function detectFrameworkFromContent(
+  src: string,
+  content?: string
+): string {
+  // First try path-based detection
+  const pathFramework = detectFrameworkFromPath(src);
+  
+  // If we have a definitive answer from path, use it
+  if (pathFramework !== "preact" || !content) {
+    return pathFramework;
+  }
+  
+  // For .tsx/.jsx files, analyze content to distinguish between Preact and Solid
+  if (content.includes("solid-js")) {
+    return "solid";
+  }
+  
+  if (content.includes("@builder.io/qwik")) {
+    return "qwik";
+  }
+  
+  if (content.includes("preact")) {
+    return "preact";
+  }
+  
+  // Default to Preact
+  return "preact";
+}
+
+/**
+ * Preload integrations for the given frameworks
+ * Useful for warming up the cache during build or startup
+ */
+export async function preloadIntegrations(frameworks: string[]): Promise<void> {
+  await Promise.all(
+    frameworks.map(framework => loadIntegration(framework))
+  );
+}
+
+/**
+ * Get all currently loaded integrations
+ */
+export function getLoadedIntegrations(): Integration[] {
+  return Array.from(integrationCache.values());
+}
+
+/**
+ * Clear the integration cache
+ * Useful for testing or hot module replacement
+ */
+export function clearIntegrationCache(): void {
+  integrationCache.clear();
+}
+
+/**
+ * Check if an integration is loaded in cache
+ */
+export function isIntegrationLoaded(framework: string): boolean {
+  return integrationCache.has(framework);
+}