@stacksjs/stx 0.2.95 → 0.2.96

package/dist/performance-utils.js

@@ -1,2 +1,430 @@
-// @bun
-import{Ax as a,Bx as b,Cx as c,Dx as d,Ex as e,Fx as f,Gx as g,Hx as h,Ix as i,Jx as j,Kx as k,Lx as l,Mx as m,Nx as n,Ox as o}from"./chunk-9ecv8aqj.js";import"./chunk-xv34zbp4.js";export{f as throttle,o as resetPerformanceMonitor,m as performanceMonitor,h as optimizedReplace,g as memoize,l as getPerformanceMonitor,b as getCachedRegex,i as expressionEvaluatorPool,k as defaultPerformanceBudgets,e as debounce,c as clearRegexCache,n as applyDefaultBudgets,d as TemplateCache,j as PerformanceMonitor,a as LRUCache};
+export class LRUCache {
+  cache = new Map;
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    if (!this.cache.has(key))
+      return;
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key))
+      this.cache.delete(key);
+    else if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0)
+        this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  values() {
+    return this.cache.values();
+  }
+}
+const REGEX_CACHE = new Map, REGEX_CACHE_MAX_SIZE = 500;
+export function getCachedRegex(pattern, flags) {
+  if (flags?.includes("g"))
+    return new RegExp(pattern, flags);
+  const key = `${pattern}:${flags || ""}`;
+  if (!REGEX_CACHE.has(key)) {
+    if (REGEX_CACHE.size >= REGEX_CACHE_MAX_SIZE) {
+      const firstKey = REGEX_CACHE.keys().next().value;
+      if (firstKey)
+        REGEX_CACHE.delete(firstKey);
+    }
+    REGEX_CACHE.set(key, new RegExp(pattern, flags));
+  }
+  return REGEX_CACHE.get(key);
+}
+export function clearRegexCache() {
+  REGEX_CACHE.clear();
+}
+
+export class TemplateCache {
+  cache = new Map;
+  maxSize;
+  ttl;
+  constructor(maxSize = 1000, ttl = 300000) {
+    this.maxSize = maxSize;
+    this.ttl = ttl;
+  }
+  get(key) {
+    const cached = this.cache.get(key);
+    if (!cached)
+      return null;
+    if (Date.now() - cached.timestamp > this.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.result;
+  }
+  set(key, result, dependencies = new Set) {
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey)
+        this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, {
+      result,
+      timestamp: Date.now(),
+      dependencies
+    });
+  }
+  invalidateDependency(filePath) {
+    let invalidated = 0;
+    for (const [key, cached] of this.cache.entries())
+      if (cached.dependencies.has(filePath)) {
+        this.cache.delete(key);
+        invalidated++;
+      }
+    return invalidated;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize
+    };
+  }
+}
+export function debounce(func, delay) {
+  let timeoutId;
+  return (...args) => {
+    if (timeoutId)
+      clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      func(...args);
+    }, delay);
+  };
+}
+export function throttle(func, delay) {
+  let lastExecution = 0, lastResult;
+  return (...args) => {
+    const now = Date.now();
+    if (now - lastExecution >= delay) {
+      lastExecution = now;
+      lastResult = func(...args);
+    }
+    return lastResult;
+  };
+}
+export function memoize(func, maxCacheSize = 100) {
+  const cache = new Map;
+  return (...args) => {
+    let key;
+    try {
+      key = JSON.stringify(args);
+    } catch {
+      return func(...args);
+    }
+    if (cache.has(key))
+      return cache.get(key);
+    if (cache.size >= maxCacheSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey)
+        cache.delete(firstKey);
+    }
+    const result = func(...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+export function optimizedReplace(text, pattern, replacement, flags) {
+  if (typeof pattern === "string") {
+    const regex = getCachedRegex(pattern, flags);
+    if (typeof replacement === "string" && flags?.includes("i")) {
+      const replacementStr = replacement;
+      return text.replace(regex, (match) => {
+        if (match === match.toUpperCase() && match !== match.toLowerCase())
+          return replacementStr.toUpperCase();
+        else if (match[0] === match[0].toUpperCase() && match[0] !== match[0].toLowerCase())
+          return replacementStr[0].toUpperCase() + replacementStr.slice(1).toLowerCase();
+        else
+          return replacementStr.toLowerCase();
+      });
+    }
+    return text.replace(regex, replacement);
+  }
+  return text.replace(pattern, replacement);
+}
+
+class ExpressionEvaluatorPool {
+  pool = [];
+  maxPoolSize = 10;
+  fnCache = new Map;
+  fnCacheMaxSize = 200;
+  getEvaluator(contextKeys) {
+    const uniqueKeys = Array.from(new Set(contextKeys)), contextSignature = uniqueKeys.sort().join(","), reusable = this.pool.find((item) => item.context.join(",") === contextSignature);
+    if (reusable)
+      return reusable.func;
+    const fnCache = this.fnCache, fnCacheMaxSize = this.fnCacheMaxSize, evaluator = (...contextValues) => {
+      return (expr) => {
+        try {
+          const cacheKey = `${contextSignature}:${expr}`;
+          let fn = fnCache.get(cacheKey);
+          if (!fn) {
+            if (fnCache.size >= fnCacheMaxSize) {
+              const firstKey = fnCache.keys().next().value;
+              if (firstKey)
+                fnCache.delete(firstKey);
+            }
+            fn = Function(...uniqueKeys, `
+              'use strict';
+              try {
+                return ${expr};
+              }
+catch (e) {
+                if (e instanceof ReferenceError || e instanceof TypeError) {
+                  return undefined;
+                }
+                throw e;
+              }
+            `);
+            fnCache.set(cacheKey, fn);
+          }
+          return fn(...contextValues);
+        } catch {
+          return;
+        }
+      };
+    };
+    if (this.pool.length < this.maxPoolSize)
+      this.pool.push({
+        func: evaluator,
+        context: uniqueKeys.slice()
+      });
+    return evaluator;
+  }
+  clear() {
+    this.pool.length = 0;
+    this.fnCache.clear();
+  }
+}
+export const expressionEvaluatorPool = new ExpressionEvaluatorPool;
+
+export class PerformanceMonitor {
+  metrics = new Map;
+  budgets = new Map;
+  violations = [];
+  maxViolations = 100;
+  violationHandlers = [];
+  enabled = !0;
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setBudget(label, budget) {
+    this.budgets.set(label, {
+      warnThreshold: 0.8,
+      action: "warn",
+      ...budget
+    });
+  }
+  setBudgets(budgets) {
+    for (const [label, budget] of Object.entries(budgets))
+      this.setBudget(label, budget);
+  }
+  removeBudget(label) {
+    this.budgets.delete(label);
+  }
+  getBudgets() {
+    const result = {};
+    for (const [label, budget] of this.budgets.entries())
+      result[label] = budget;
+    return result;
+  }
+  onViolation(handler) {
+    this.violationHandlers.push(handler);
+  }
+  offViolation(handler) {
+    const index = this.violationHandlers.indexOf(handler);
+    if (index !== -1)
+      this.violationHandlers.splice(index, 1);
+  }
+  time(label, fn) {
+    if (!this.enabled)
+      return fn();
+    const start = performance.now(), result = fn(), duration = performance.now() - start;
+    this.recordTime(label, duration);
+    this.checkBudget(label, duration);
+    return result;
+  }
+  async timeAsync(label, fn) {
+    if (!this.enabled)
+      return fn();
+    const start = performance.now(), result = await fn(), duration = performance.now() - start;
+    this.recordTime(label, duration);
+    this.checkBudget(label, duration);
+    return result;
+  }
+  checkBudget(label, duration) {
+    const budget = this.budgets.get(label);
+    if (!budget)
+      return;
+    const exceedancePercent = duration / budget.maxTime * 100, isWarning = budget.warnThreshold !== void 0 ? duration >= budget.maxTime * budget.warnThreshold && duration < budget.maxTime : !1, isViolation = duration >= budget.maxTime;
+    if (!isWarning && !isViolation)
+      return;
+    const violation = {
+      label,
+      actualTime: duration,
+      budgetTime: budget.maxTime,
+      exceedancePercent,
+      timestamp: new Date,
+      isWarning
+    };
+    this.violations.push(violation);
+    while (this.violations.length > this.maxViolations)
+      this.violations.shift();
+    for (const handler of this.violationHandlers)
+      try {
+        handler(violation);
+      } catch {}
+    const message = isWarning ? `[Performance Warning] "${label}" took ${duration.toFixed(2)}ms (${exceedancePercent.toFixed(1)}% of ${budget.maxTime}ms budget)` : `[Performance Budget Exceeded] "${label}" took ${duration.toFixed(2)}ms (exceeded ${budget.maxTime}ms budget by ${(exceedancePercent - 100).toFixed(1)}%)`;
+    switch (budget.action) {
+      case "log":
+        console.log(message);
+        break;
+      case "warn":
+        console.warn(message);
+        break;
+      case "error":
+        console.error(message);
+        break;
+      case "throw":
+        if (isViolation)
+          throw Error(message);
+        else
+          console.warn(message);
+        break;
+    }
+  }
+  recordTime(label, duration) {
+    const existing = this.metrics.get(label);
+    if (existing) {
+      existing.count++;
+      existing.totalTime += duration;
+      existing.maxTime = Math.max(existing.maxTime, duration);
+      existing.minTime = Math.min(existing.minTime, duration);
+    } else
+      this.metrics.set(label, {
+        count: 1,
+        totalTime: duration,
+        maxTime: duration,
+        minTime: duration
+      });
+  }
+  getStats(label) {
+    if (label) {
+      const metric = this.metrics.get(label);
+      if (!metric)
+        return {};
+      const budget = this.budgets.get(label);
+      return {
+        count: metric.count,
+        avgTime: metric.totalTime / metric.count,
+        totalTime: metric.totalTime,
+        maxTime: metric.maxTime,
+        minTime: metric.minTime,
+        budget: budget?.maxTime,
+        budgetUtilization: budget ? metric.totalTime / metric.count / budget.maxTime * 100 : void 0
+      };
+    }
+    const stats = {};
+    for (const [key, metric] of this.metrics.entries()) {
+      const budget = this.budgets.get(key);
+      stats[key] = {
+        count: metric.count,
+        avgTime: metric.totalTime / metric.count,
+        totalTime: metric.totalTime,
+        maxTime: metric.maxTime,
+        minTime: metric.minTime,
+        budget: budget?.maxTime,
+        budgetUtilization: budget ? metric.totalTime / metric.count / budget.maxTime * 100 : void 0
+      };
+    }
+    return stats;
+  }
+  getViolations(label) {
+    if (label)
+      return this.violations.filter((v) => v.label === label);
+    return [...this.violations];
+  }
+  getViolationStats() {
+    const byLabel = {};
+    let warnings = 0, errors = 0;
+    for (const v of this.violations) {
+      byLabel[v.label] = (byLabel[v.label] || 0) + 1;
+      if (v.isWarning)
+        warnings++;
+      else
+        errors++;
+    }
+    return { total: this.violations.length, byLabel, warnings, errors };
+  }
+  clear() {
+    this.metrics.clear();
+  }
+  clearViolations() {
+    this.violations.length = 0;
+  }
+  clearBudgets() {
+    this.budgets.clear();
+  }
+  reset() {
+    this.clear();
+    this.clearViolations();
+    this.clearBudgets();
+    this.violationHandlers.length = 0;
+  }
+}
+export const defaultPerformanceBudgets = {
+  processDirectives: { maxTime: 500, warnThreshold: 0.8, action: "warn" },
+  processTemplate: { maxTime: 200, warnThreshold: 0.8, action: "warn" },
+  processIncludes: { maxTime: 100, warnThreshold: 0.8, action: "warn" },
+  processLoops: { maxTime: 50, warnThreshold: 0.8, action: "warn" },
+  processConditionals: { maxTime: 50, warnThreshold: 0.8, action: "warn" },
+  processExpressions: { maxTime: 100, warnThreshold: 0.8, action: "warn" },
+  renderComponent: { maxTime: 150, warnThreshold: 0.8, action: "warn" },
+  buildWebComponents: { maxTime: 1000, warnThreshold: 0.8, action: "warn" }
+};
+let _performanceMonitor = null;
+export function getPerformanceMonitor() {
+  if (!_performanceMonitor)
+    _performanceMonitor = new PerformanceMonitor;
+  return _performanceMonitor;
+}
+export const performanceMonitor = new Proxy({}, {
+  get(_target, prop) {
+    return getPerformanceMonitor()[prop];
+  }
+});
+export function applyDefaultBudgets(monitor = getPerformanceMonitor()) {
+  monitor.setBudgets(defaultPerformanceBudgets);
+}
+export function resetPerformanceMonitor() {
+  _performanceMonitor = null;
+}

package/dist/placeholder.js

@@ -1,2 +1,35 @@
-// @bun
-import{$t as a,au as b,bu as c,cu as d,du as e,eu as f}from"./chunk-hjm2xab3.js";import"./chunk-xv34zbp4.js";export{a as resetPlaceholders,e as replacePlaceholders,f as hasPlaceholders,c as getPlaceholderRegistry,d as extractPlaceholders,b as createPlaceholder};
+let placeholderCounter = 0;
+const placeholderRegistry = new Map;
+export function resetPlaceholders() {
+  placeholderCounter = 0;
+  placeholderRegistry.clear();
+}
+export function createPlaceholder(type, expr) {
+  const id = placeholderCounter++, token = `<!--__STX_${type.toUpperCase()}_${id}__-->`;
+  placeholderRegistry.set(token, { type, expression: expr });
+  return token;
+}
+export function getPlaceholderRegistry() {
+  const map = {};
+  for (const [token, info] of placeholderRegistry)
+    map[token] = { type: info.type, expression: info.expression };
+  return map;
+}
+export function extractPlaceholders(html) {
+  const map = {}, regex = /<!--__STX_(EXPR|COND|RAW)_(\d+)__-->/g;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    const token = match[0], type = match[1].toLowerCase(), registered = placeholderRegistry.get(token);
+    map[token] = { type, expression: registered?.expression || "" };
+  }
+  return map;
+}
+export function replacePlaceholders(html, values) {
+  let result = html;
+  for (const [token, value] of values)
+    result = result.split(token).join(value);
+  return result;
+}
+export function hasPlaceholders(html) {
+  return html.includes("<!--__STX_");
+}

package/dist/plugin-system.js

@@ -1,2 +1,214 @@
-// @bun
-import{oj as a,pj as b,qj as c,rj as d,sj as e,tj as f,uj as g,vj as h}from"./chunk-vw7vqd76.js";import"./chunk-xv34zbp4.js";export{g as timingPlugin,c as pluginManager,a as definePlugin,f as debugPlugin,h as createVariablesPlugin,e as createFilterPlugin,d as createDirectivePlugin,b as PluginManager};
+export function definePlugin(config) {
+  return config;
+}
+
+export class PluginManager {
+  plugins = new Map;
+  sortedPlugins = [];
+  initialized = !1;
+  async register(plugin, options) {
+    if (this.plugins.has(plugin.name))
+      throw Error(`Plugin "${plugin.name}" is already registered`);
+    if (plugin.dependencies) {
+      for (const dep of plugin.dependencies)
+        if (!this.plugins.has(dep))
+          throw Error(`Plugin "${plugin.name}" depends on "${dep}" which is not registered`);
+    }
+    this.plugins.set(plugin.name, plugin);
+    if (plugin.onRegister)
+      await plugin.onRegister(options);
+    this.sortPlugins();
+  }
+  async unregister(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin)
+      return !1;
+    for (const [otherName, otherPlugin] of this.plugins)
+      if (otherPlugin.dependencies?.includes(name))
+        throw Error(`Cannot unregister "${name}" because "${otherName}" depends on it`);
+    if (plugin.onUnregister)
+      await plugin.onUnregister();
+    this.plugins.delete(name);
+    this.sortPlugins();
+    return !0;
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  has(name) {
+    return this.plugins.has(name);
+  }
+  getAll() {
+    return [...this.sortedPlugins];
+  }
+  getAllDirectives() {
+    const directives = [];
+    for (const plugin of this.sortedPlugins)
+      if (plugin.registerDirectives)
+        directives.push(...plugin.registerDirectives());
+    return directives;
+  }
+  getAllFilters() {
+    const filters = {};
+    for (const plugin of this.sortedPlugins)
+      if (plugin.registerFilters)
+        Object.assign(filters, plugin.registerFilters());
+    return filters;
+  }
+  async runBeforeProcess(ctx) {
+    return this.runHooks("beforeProcess", ctx);
+  }
+  async runAfterParse(ctx) {
+    return this.runHooks("afterParse", ctx);
+  }
+  async runBeforeDirective(phase, ctx) {
+    return this.runDirectiveHooks("beforeDirective", phase, ctx);
+  }
+  async runAfterDirective(phase, ctx) {
+    return this.runDirectiveHooks("afterDirective", phase, ctx);
+  }
+  async runBeforeRender(ctx) {
+    return this.runHooks("beforeRender", ctx);
+  }
+  async runAfterRender(ctx) {
+    return this.runHooks("afterRender", ctx);
+  }
+  async runOnError(ctx) {
+    for (const plugin of this.sortedPlugins)
+      if (plugin.onError)
+        try {
+          const result = await plugin.onError(ctx);
+          if (result) {
+            if (result.template !== void 0)
+              ctx.template = result.template;
+            if (result.context)
+              ctx.context = { ...ctx.context, ...result.context };
+            if (result.metadata)
+              ctx.metadata = { ...ctx.metadata, ...result.metadata };
+            if (result.skip)
+              return ctx;
+          }
+        } catch (hookError) {
+          console.error(`Error in plugin "${plugin.name}" onError hook:`, hookError);
+        }
+    return null;
+  }
+  sortPlugins() {
+    this.sortedPlugins = Array.from(this.plugins.values()).sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+  }
+  async runHooks(hookName, ctx) {
+    const currentCtx = { ...ctx };
+    for (const plugin of this.sortedPlugins) {
+      const hook = plugin[hookName];
+      if (hook)
+        try {
+          const result = await hook(currentCtx);
+          if (result) {
+            if (result.template !== void 0)
+              currentCtx.template = result.template;
+            if (result.context)
+              currentCtx.context = { ...currentCtx.context, ...result.context };
+            if (result.metadata)
+              currentCtx.metadata = { ...currentCtx.metadata, ...result.metadata };
+            if (result.skip)
+              break;
+          }
+        } catch (error) {
+          console.error(`Error in plugin "${plugin.name}" ${hookName} hook:`, error);
+        }
+    }
+    return currentCtx;
+  }
+  async runDirectiveHooks(hookName, phase, ctx) {
+    const currentCtx = { ...ctx };
+    for (const plugin of this.sortedPlugins) {
+      const hook = plugin[hookName];
+      if (hook)
+        try {
+          const result = await hook(phase, currentCtx);
+          if (result) {
+            if (result.template !== void 0)
+              currentCtx.template = result.template;
+            if (result.context)
+              currentCtx.context = { ...currentCtx.context, ...result.context };
+            if (result.metadata)
+              currentCtx.metadata = { ...currentCtx.metadata, ...result.metadata };
+            if (result.skip)
+              break;
+          }
+        } catch (error) {
+          console.error(`Error in plugin "${plugin.name}" ${hookName} hook:`, error);
+        }
+    }
+    return currentCtx;
+  }
+}
+export const pluginManager = new PluginManager;
+export function createDirectivePlugin(name, directives, options = {}) {
+  return {
+    name,
+    ...options,
+    registerDirectives: () => directives
+  };
+}
+export function createFilterPlugin(name, filters, options = {}) {
+  return {
+    name,
+    ...options,
+    registerFilters: () => filters
+  };
+}
+export const debugPlugin = definePlugin({
+  name: "stx-debug",
+  version: "1.0.0",
+  description: "Logs all plugin lifecycle events for debugging",
+  priority: 0,
+  beforeProcess(ctx) {
+    console.log("[stx-debug] beforeProcess:", ctx.filePath);
+  },
+  afterParse(ctx) {
+    console.log("[stx-debug] afterParse:", ctx.template.length, "chars");
+  },
+  beforeDirective(phase, _ctx) {
+    console.log("[stx-debug] beforeDirective:", phase);
+  },
+  afterDirective(phase, _ctx) {
+    console.log("[stx-debug] afterDirective:", phase);
+  },
+  beforeRender(_ctx) {
+    console.log("[stx-debug] beforeRender");
+  },
+  afterRender(ctx) {
+    console.log("[stx-debug] afterRender:", ctx.template.length, "chars");
+  },
+  onError(ctx) {
+    console.error("[stx-debug] onError:", ctx.error.message, "in phase:", ctx.phase);
+  }
+}), timingPlugin = definePlugin({
+  name: "stx-timing",
+  version: "1.0.0",
+  description: "Measures template processing time",
+  priority: 1,
+  beforeProcess(ctx) {
+    ctx.metadata.startTime = performance.now();
+  },
+  afterRender(ctx) {
+    const startTime = ctx.metadata.startTime;
+    if (startTime) {
+      const duration = performance.now() - startTime;
+      console.log(`[stx-timing] Processing took ${duration.toFixed(2)}ms`);
+    }
+  }
+});
+export function createVariablesPlugin(variables) {
+  return definePlugin({
+    name: "stx-variables",
+    version: "1.0.0",
+    description: "Adds predefined variables to template context",
+    beforeProcess(ctx) {
+      return {
+        context: { ...ctx.context, ...variables }
+      };
+    }
+  });
+}