@tontoko/fast-playwright-mcp 0.0.4

package/lib/diagnostics/diagnostic-thresholds.js

@@ -0,0 +1,347 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/diagnostics/diagnostic-thresholds.ts
+import { THRESHOLDS, TIMEOUTS } from "../config/constants.js";
+var DEFAULT_THRESHOLDS = {
+  executionTime: {
+    pageAnalysis: TIMEOUTS.PAGE_ANALYSIS_TIMEOUT,
+    elementDiscovery: TIMEOUTS.ELEMENT_DISCOVERY_TIMEOUT,
+    resourceMonitoring: 200,
+    parallelAnalysis: TIMEOUTS.PARALLEL_ANALYSIS_TIMEOUT
+  },
+  memory: {
+    maxMemoryUsage: 100 * 1024 * 1024,
+    memoryLeakThreshold: 50 * 1024 * 1024,
+    gcTriggerThreshold: 80 * 1024 * 1024
+  },
+  performance: {
+    domElementLimit: 1e4,
+    maxDepthLimit: 50,
+    largeSubtreeThreshold: THRESHOLDS.LARGE_SUBTREE_ELEMENTS
+  },
+  dom: {
+    totalElements: 1e4,
+    maxDepth: 50,
+    largeSubtrees: 10,
+    elementsWarning: THRESHOLDS.ELEMENTS_WARNING,
+    elementsDanger: THRESHOLDS.ELEMENTS_DANGER,
+    depthWarning: 15,
+    depthDanger: 20,
+    largeSubtreeThreshold: THRESHOLDS.SMALL_SUBTREE_ELEMENTS
+  },
+  interaction: {
+    clickableElements: 100,
+    formElements: 50,
+    clickableHigh: 100
+  },
+  layout: {
+    fixedElements: 10,
+    highZIndexElements: 5,
+    highZIndexThreshold: THRESHOLDS.HIGH_Z_INDEX,
+    excessiveZIndexThreshold: 9999
+  }
+};
+function createPositiveNumberRule(fieldName, getValue) {
+  return (obj, errors) => {
+    if (getValue(obj) <= 0) {
+      errors.push(`${fieldName} must be positive`);
+    }
+  };
+}
+function createComparisonRule(getValue1, getValue2, message) {
+  return (obj, errors) => {
+    if (getValue2(obj) <= getValue1(obj)) {
+      errors.push(message);
+    }
+  };
+}
+class DiagnosticThresholds {
+  static instance = null;
+  currentThresholds;
+  constructor(initialConfig) {
+    this.currentThresholds = this.mergeWithDefaults(initialConfig ?? {});
+    this.validateThresholds(this.currentThresholds);
+  }
+  static getInstance(config) {
+    if (!DiagnosticThresholds.instance) {
+      DiagnosticThresholds.instance = new DiagnosticThresholds(config);
+    } else if (config) {
+      DiagnosticThresholds.instance.updateThresholds(config);
+    }
+    return DiagnosticThresholds.instance;
+  }
+  static reset() {
+    DiagnosticThresholds.instance = null;
+  }
+  getMetricsThresholds() {
+    const thresholds = this.currentThresholds;
+    return {
+      executionTime: {
+        pageAnalysis: thresholds.executionTime.pageAnalysis,
+        elementDiscovery: thresholds.executionTime.elementDiscovery,
+        resourceMonitoring: thresholds.executionTime.resourceMonitoring,
+        parallelAnalysis: thresholds.executionTime.parallelAnalysis
+      },
+      memory: {
+        maxMemoryUsage: thresholds.memory.maxMemoryUsage,
+        memoryLeakThreshold: thresholds.memory.memoryLeakThreshold,
+        gcTriggerThreshold: thresholds.memory.gcTriggerThreshold
+      },
+      performance: {
+        domElementLimit: thresholds.performance.domElementLimit,
+        maxDepthLimit: thresholds.performance.maxDepthLimit,
+        largeSubtreeThreshold: thresholds.performance.largeSubtreeThreshold
+      },
+      dom: {
+        totalElements: thresholds.dom.totalElements,
+        maxDepth: thresholds.dom.maxDepth,
+        largeSubtrees: thresholds.dom.largeSubtrees,
+        elementsWarning: thresholds.dom.elementsWarning,
+        elementsDanger: thresholds.dom.elementsDanger,
+        depthWarning: thresholds.dom.depthWarning,
+        depthDanger: thresholds.dom.depthDanger,
+        largeSubtreeThreshold: thresholds.dom.largeSubtreeThreshold
+      },
+      interaction: {
+        clickableElements: thresholds.interaction.clickableElements,
+        formElements: thresholds.interaction.formElements,
+        clickableHigh: thresholds.interaction.clickableHigh
+      },
+      layout: {
+        fixedElements: thresholds.layout.fixedElements,
+        highZIndexElements: thresholds.layout.highZIndexElements,
+        highZIndexThreshold: thresholds.layout.highZIndexThreshold,
+        excessiveZIndexThreshold: thresholds.layout.excessiveZIndexThreshold
+      }
+    };
+  }
+  getDomThresholds() {
+    return this.currentThresholds.dom;
+  }
+  getPerformanceThresholds() {
+    return this.currentThresholds.performance;
+  }
+  getInteractionThresholds() {
+    return this.currentThresholds.interaction;
+  }
+  getLayoutThresholds() {
+    return this.currentThresholds.layout;
+  }
+  getExecutionTimeThresholds() {
+    return this.currentThresholds.executionTime;
+  }
+  getMemoryThresholds() {
+    return this.currentThresholds.memory;
+  }
+  updateThresholds(partialConfig) {
+    const previousThresholds = { ...this.currentThresholds };
+    try {
+      const newThresholds = this.mergeWithCurrentThresholds(partialConfig);
+      this.validateThresholds(newThresholds);
+      this.currentThresholds = newThresholds;
+    } catch (error) {
+      this.currentThresholds = previousThresholds;
+      throw error;
+    }
+  }
+  mergeWithDefaults(config) {
+    const result = JSON.parse(JSON.stringify(DEFAULT_THRESHOLDS));
+    if (config.executionTime) {
+      Object.assign(result.executionTime, config.executionTime);
+    }
+    if (config.memory) {
+      Object.assign(result.memory, config.memory);
+    }
+    if (config.performance) {
+      Object.assign(result.performance, config.performance);
+    }
+    if (config.dom) {
+      Object.assign(result.dom, config.dom);
+    }
+    if (config.interaction) {
+      Object.assign(result.interaction, config.interaction);
+    }
+    if (config.layout) {
+      Object.assign(result.layout, config.layout);
+    }
+    return result;
+  }
+  mergeWithCurrentThresholds(config) {
+    const result = JSON.parse(JSON.stringify(this.currentThresholds));
+    if (config.executionTime) {
+      Object.assign(result.executionTime, config.executionTime);
+    }
+    if (config.memory) {
+      Object.assign(result.memory, config.memory);
+    }
+    if (config.performance) {
+      Object.assign(result.performance, config.performance);
+    }
+    if (config.dom) {
+      Object.assign(result.dom, config.dom);
+    }
+    if (config.interaction) {
+      Object.assign(result.interaction, config.interaction);
+    }
+    if (config.layout) {
+      Object.assign(result.layout, config.layout);
+    }
+    return result;
+  }
+  validateThresholds(thresholds) {
+    const errors = [];
+    const executionTimeRules = [
+      createPositiveNumberRule("pageAnalysis execution time", (exec) => exec.pageAnalysis),
+      createPositiveNumberRule("elementDiscovery execution time", (exec) => exec.elementDiscovery),
+      createPositiveNumberRule("resourceMonitoring execution time", (exec) => exec.resourceMonitoring),
+      createPositiveNumberRule("parallelAnalysis execution time", (exec) => exec.parallelAnalysis)
+    ];
+    const memoryRules = [
+      createPositiveNumberRule("maxMemoryUsage", (mem) => mem.maxMemoryUsage),
+      createPositiveNumberRule("memoryLeakThreshold", (mem) => mem.memoryLeakThreshold),
+      createPositiveNumberRule("gcTriggerThreshold", (mem) => mem.gcTriggerThreshold),
+      createComparisonRule((mem) => mem.memoryLeakThreshold, (mem) => mem.maxMemoryUsage, "memoryLeakThreshold should be less than maxMemoryUsage")
+    ];
+    const domRules = [
+      createPositiveNumberRule("elementsWarning", (dom) => dom.elementsWarning),
+      createPositiveNumberRule("depthWarning", (dom) => dom.depthWarning),
+      createPositiveNumberRule("largeSubtreeThreshold", (dom) => dom.largeSubtreeThreshold),
+      createComparisonRule((dom) => dom.elementsWarning, (dom) => dom.elementsDanger, "elementsDanger must be greater than elementsWarning"),
+      createComparisonRule((dom) => dom.depthWarning, (dom) => dom.depthDanger, "depthDanger must be greater than depthWarning")
+    ];
+    const interactionRules = [
+      createPositiveNumberRule("clickableElements threshold", (inter) => inter.clickableElements),
+      createPositiveNumberRule("formElements threshold", (inter) => inter.formElements)
+    ];
+    const layoutRules = [
+      createPositiveNumberRule("highZIndexThreshold", (layout) => layout.highZIndexThreshold),
+      createComparisonRule((layout) => layout.highZIndexThreshold, (layout) => layout.excessiveZIndexThreshold, "excessiveZIndexThreshold must be greater than highZIndexThreshold")
+    ];
+    this.applyValidationRules(thresholds.executionTime, executionTimeRules, errors);
+    this.applyValidationRules(thresholds.memory, memoryRules, errors);
+    this.applyValidationRules(thresholds.dom, domRules, errors);
+    this.applyValidationRules(thresholds.interaction, interactionRules, errors);
+    this.applyValidationRules(thresholds.layout, layoutRules, errors);
+    if (errors.length > 0) {
+      throw new Error(`Invalid threshold configuration: ${errors.join(", ")}`);
+    }
+  }
+  applyValidationRules(section, rules, errors) {
+    for (const rule of rules) {
+      rule(section, errors);
+    }
+  }
+  getConfigDiagnostics() {
+    const customizations = [];
+    const warnings = [];
+    const defaultsUsed = [];
+    const defaults = DEFAULT_THRESHOLDS;
+    const current = this.currentThresholds;
+    const currentDom = current.dom;
+    const defaultsDom = defaults.dom;
+    const currentLayout = current.layout;
+    const defaultsLayout = defaults.layout;
+    if (currentDom.elementsWarning !== defaultsDom.elementsWarning) {
+      customizations.push(`DOM elements warning: ${currentDom.elementsWarning} (default: ${defaultsDom.elementsWarning})`);
+    }
+    if (currentDom.elementsDanger !== defaultsDom.elementsDanger) {
+      customizations.push(`DOM elements danger: ${currentDom.elementsDanger} (default: ${defaultsDom.elementsDanger})`);
+    }
+    if (currentDom.depthWarning !== defaultsDom.depthWarning) {
+      customizations.push(`DOM depth warning: ${currentDom.depthWarning} (default: ${defaultsDom.depthWarning})`);
+    }
+    if (currentDom.depthDanger !== defaultsDom.depthDanger) {
+      customizations.push(`DOM depth danger: ${currentDom.depthDanger} (default: ${defaultsDom.depthDanger})`);
+    }
+    if (currentLayout.excessiveZIndexThreshold !== defaultsLayout.excessiveZIndexThreshold) {
+      customizations.push(`Z-index excessive: ${currentLayout.excessiveZIndexThreshold} (default: ${defaultsLayout.excessiveZIndexThreshold})`);
+    }
+    if (currentDom.elementsWarning > 2000) {
+      warnings.push("DOM elements warning threshold is very high - may not catch performance issues early");
+    }
+    if (currentDom.depthWarning > 25) {
+      warnings.push("DOM depth warning threshold is very high - deeply nested structures may cause performance issues");
+    }
+    if (currentLayout.excessiveZIndexThreshold < 1000) {
+      warnings.push("Excessive z-index threshold is low - may generate false positives");
+    }
+    if (customizations.length === 0) {
+      defaultsUsed.push("All thresholds using default values");
+    }
+    return {
+      status: "valid",
+      customizations,
+      warnings,
+      defaultsUsed
+    };
+  }
+  resetToDefaults() {
+    this.currentThresholds = { ...DEFAULT_THRESHOLDS };
+  }
+}
+function getCurrentThresholds() {
+  return DiagnosticThresholds.getInstance();
+}
+function getMetricsThresholds() {
+  return getCurrentThresholds().getMetricsThresholds();
+}
+
+class ThresholdConfigBuilder {
+  config = {};
+  executionTime(config) {
+    this.config.executionTime = { ...this.config.executionTime, ...config };
+    return this;
+  }
+  memory(config) {
+    this.config.memory = { ...this.config.memory, ...config };
+    return this;
+  }
+  performance(config) {
+    this.config.performance = { ...this.config.performance, ...config };
+    return this;
+  }
+  dom(config) {
+    this.config.dom = { ...this.config.dom, ...config };
+    return this;
+  }
+  interaction(config) {
+    this.config.interaction = { ...this.config.interaction, ...config };
+    return this;
+  }
+  layout(config) {
+    this.config.layout = { ...this.config.layout, ...config };
+    return this;
+  }
+  build() {
+    return { ...this.config };
+  }
+  create() {
+    return DiagnosticThresholds.getInstance(this.build());
+  }
+  static create() {
+    return new ThresholdConfigBuilder;
+  }
+}
+export {
+  getMetricsThresholds,
+  getCurrentThresholds,
+  ThresholdConfigBuilder,
+  DiagnosticThresholds
+};