@stacksjs/stx 0.0.9 → 0.1.6

package/dist/performance-utils.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Get a cached regex pattern or compile and cache it
+ */
+export declare function getCachedRegex(pattern: string, flags?: string): RegExp;
+/**
+ * Debounce function calls to avoid excessive processing
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Throttle function calls to limit execution frequency
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => ReturnType<T> | undefined;
+/**
+ * Memoize function results to avoid repeated calculations
+ */
+export declare function memoize<T extends (...args: any[]) => any>(func: T, maxCacheSize?: any): T;
+/**
+ * Optimized string replacement that reuses regex patterns with case-preserving support
+ */
+export declare function optimizedReplace(text: string, pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string), flags?: string): string;
+// Global expression evaluator pool
+export declare const expressionEvaluatorPool: ExpressionEvaluatorPool;
+// Global performance monitor instance
+export declare const performanceMonitor: PerformanceMonitor;
+/**
+ * Cache for template processing results
+ */
+export declare class TemplateCache {
+  private cache: any;
+  private maxSize: number;
+  private ttl: number;
+  constructor(maxSize?: any, ttl?: number);
+  get(key: string): string | null;
+  set(key: string, result: string, dependencies?: Set<string>): void;
+  invalidateDependency(filePath: string): number;
+  clear(): void;
+  getStats(): { size: number, maxSize: number, hitRate?: number };
+}
+/**
+ * Pool of worker contexts to avoid creating new Function instances
+ */
+declare class ExpressionEvaluatorPool {
+  private pool: Array<{ func: (...args: any[]) => any, context: string[] }>;
+  private maxPoolSize: any;
+  getEvaluator(contextKeys: string[]): (...args: any[]) => any;
+  clear(): void;
+}
+/**
+ * Performance monitor for tracking processing times
+ */
+export declare class PerformanceMonitor {
+  private metrics: any;
+  time<T>(label: string, fn: () => T): T;
+  timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
+  recordTime(label: string, duration: number): void;
+  getStats(label?: string): Record<string, any>;
+  clear(): void;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,2 @@
+export declare const plugin: BunPlugin;
+export default plugin;

package/dist/process.d.ts

@@ -1,11 +1,13 @@
 import type { StxOptions } from './types';
-
+/**
+ * Process all template directives with enhanced error handling and performance monitoring
+ */
 export declare function processDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
-declare function processOtherDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
-declare function processComponentDirectives(template: string, context: Record<string, any>, filePath: string, componentsDir: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
-declare let props: {};
-declare const propsFn: unknown;
-declare const processedContent: unknown;
-declare function processCustomElements(template: string, context: Record<string, any>, filePath: string, componentsDir: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
+/**
+ * Process @json directive to output JSON
+ */
 export declare function processJsonDirective(template: string, context: Record<string, any>): string;
+/**
+ * Process @once directive blocks
+ */
 export declare function processOnceDirective(template: string): string;

package/dist/release.d.ts

@@ -0,0 +1 @@
+export declare const gitHash: string;

package/dist/routes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Set the base URL for the application
+ */
+export declare function setAppUrl(url: string): void;
+/**
+ * Register a route with a name
+ */
+export declare function defineRoute(name: string, path: string, params?: Record<string, any>): void;
+/**
+ * Define multiple routes at once
+ */
+export declare function defineRoutes(routeDefinitions: Record<string, string | RouteDefinition>): void;
+/**
+ * Generate a URL for a named route with parameters
+ */
+export declare function route(name: string, params?: Record<string, any>, absolute?: any): string;
+/**
+ * Create a route URL directive processor for stx templates
+ */
+export declare function processRouteDirectives(template: string): string;
+/**
+ * Reset all routes (mainly for testing)
+ */
+export declare function resetRoutes(): void;
+/**
+ * Laravel-like named routes system for stx
+ *
+ * This provides the ability to define routes with names and generate URLs for them,
+ * similar to Laravel's route naming and the route() helper.
+ */
+/* eslint-disable no-new-func */
+declare interface RouteDefinition {
+  path: string
+  name?: string
+  params?: Record<string, any>
+}

package/dist/safe-evaluator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Sanitize an expression by checking for dangerous patterns
+ */
+export declare function sanitizeExpression(expression: string): string;
+/**
+ * Create a safer context object that only exposes safe properties
+ */
+export declare function createSafeContext(context: Record<string, any>): Record<string, any>;
+/**
+ * Safely evaluate an expression with the given context
+ */
+export declare function safeEvaluate(expression: string, context: Record<string, any>): any;
+/**
+ * Check if an expression is safe to evaluate
+ */
+export declare function isExpressionSafe(expression: string): boolean;

package/dist/seo.d.ts

@@ -0,0 +1,33 @@
+import type { CustomDirective, StxOptions } from './types';
+/**
+ * Process @meta directive for generating meta tags
+ */
+export declare function processMetaDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions): string;
+/**
+ * Process @structuredData directive for JSON-LD
+ */
+export declare function processStructuredData(template: string, context: Record<string, any>, filePath: string): string;
+/**
+ * Process @seo directive for automatic meta tag generation
+ */
+export declare function processSeoDirective(template: string, context: Record<string, any>, filePath: string, options: StxOptions): string;
+/**
+ * Injects default SEO tags if no @seo directive is used
+ */
+export declare function injectSeoTags(html: string, context: Record<string, any>, options: StxOptions): string;
+/**
+ * Register SEO directives
+ */
+export declare function registerSeoDirectives(): CustomDirective[];
+/**
+ * SEO meta directive for basic meta tag generation
+ */
+export declare const metaDirective: CustomDirective;
+/**
+ * SEO structured data directive for JSON-LD generation
+ */
+export declare const structuredDataDirective: CustomDirective;
+declare interface StructuredData {
+  '@context': string
+  '@type': string
+}

package/dist/serve.d.ts

@@ -0,0 +1,35 @@
+import type { Server } from 'bun';
+import type { StxOptions } from './types';
+/**
+ * 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
+  stxOptions?: StxOptions
+  watch?: boolean
+  onRequest?: (request: Request) => Response | 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
+  stop: () => void
+  url: string
+}