@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/performance-utils.js

@@ -0,0 +1,466 @@
+export class LRUCache {
+  cache = new Map;
+  maxSize;
+  options;
+  sizes;
+  bytes = 0;
+  constructor(maxSize = 100, options) {
+    this.maxSize = maxSize;
+    this.options = options ?? null;
+    this.sizes = options ? new Map : null;
+  }
+  get byteSize() {
+    return this.bytes;
+  }
+  setMaxBytes(maxBytes) {
+    if (!this.options)
+      return;
+    this.options = { ...this.options, maxBytes };
+    while (this.bytes > maxBytes && this.cache.size > 0) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey === void 0)
+        break;
+      this.delete(oldestKey);
+    }
+  }
+  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.delete(key);
+    const size = this.options ? this.options.sizeOf(value) : 0;
+    if (this.options && size > this.options.maxBytes)
+      return;
+    while (this.cache.size > 0 && (this.cache.size >= this.maxSize || this.options !== null && this.bytes + size > this.options.maxBytes)) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey === void 0)
+        break;
+      this.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+    if (this.sizes) {
+      this.sizes.set(key, size);
+      this.bytes += size;
+    }
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    if (this.sizes) {
+      const size = this.sizes.get(key);
+      if (size !== void 0) {
+        this.bytes -= size;
+        this.sizes.delete(key);
+      }
+    }
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+    this.sizes?.clear();
+    this.bytes = 0;
+  }
+  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.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Placeholder Token System
+ *
+ * Generates and resolves placeholder tokens for the template pre-compilation pipeline.
+ * During build mode, dynamic expressions are replaced with placeholder tokens.
+ * At serve time, only the placeholders are resolved with request-time data.
+ *
+ * @module placeholder
+ */
+/**
+ * Reset the placeholder counter and registry (for testing / between builds).
+ */
+export declare function resetPlaceholders(): void;
+/**
+ * Create a unique placeholder token and register the expression.
+ *
+ * @param type - The type of placeholder ('expr' for expressions, 'cond' for conditionals)
+ * @param expr - The original expression (stored in the registry for serve-time hydration)
+ * @returns A unique placeholder token string
+ */
+export declare function createPlaceholder(type: 'expr' | 'cond' | 'raw', expr: string): string;
+/**
+ * Get the registered placeholder map (all tokens created since last reset).
+ * Used by the template compiler to build the CompiledTemplate.placeholders field.
+ */
+export declare function getPlaceholderRegistry(): PlaceholderMap;
+/**
+ * A map of placeholder tokens to their original expressions.
+ */
+export interface PlaceholderMap {
+    [token: string]: {
+        type: 'expr' | 'cond' | 'raw';
+        expression: string;
+    };
+}
+/**
+ * Extract all placeholder tokens from compiled HTML.
+ *
+ * @returns A map of token → expression info
+ */
+export declare function extractPlaceholders(html: string): PlaceholderMap;
+/**
+ * Replace placeholder tokens with evaluated values.
+ * Uses simple string replacement for maximum performance.
+ *
+ * @param html - The compiled HTML with placeholder tokens
+ * @param values - Map of placeholder token → resolved value
+ * @returns HTML with all placeholders replaced
+ */
+export declare function replacePlaceholders(html: string, values: Map<string, string>): string;
+/**
+ * Check if HTML contains any placeholder tokens.
+ */
+export declare function hasPlaceholders(html: string): boolean;

package/dist/placeholder.js

@@ -0,0 +1,35 @@
+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_");
+}