@esengine/server 1.2.0 → 2.0.0

package/dist/ratelimit/index.js

@@ -0,0 +1,818 @@
+import { __name, __publicField } from '../chunk-T626JPC7.js';
+
+// src/ratelimit/strategies/TokenBucket.ts
+var _TokenBucketStrategy = class _TokenBucketStrategy {
+  /**
+   * @zh 创建令牌桶策略
+   * @en Create token bucket strategy
+   *
+   * @param config - @zh 配置 @en Configuration
+   * @param config.rate - @zh 每秒添加的令牌数 @en Tokens added per second
+   * @param config.capacity - @zh 桶容量（最大令牌数）@en Bucket capacity (max tokens)
+   */
+  constructor(config) {
+    __publicField(this, "name", "token-bucket");
+    __publicField(this, "_rate");
+    __publicField(this, "_capacity");
+    __publicField(this, "_buckets", /* @__PURE__ */ new Map());
+    this._rate = config.rate;
+    this._capacity = config.capacity;
+  }
+  /**
+   * @zh 尝试消费令牌
+   * @en Try to consume tokens
+   */
+  consume(key, cost = 1) {
+    const now = Date.now();
+    const bucket = this._getOrCreateBucket(key, now);
+    this._refillBucket(bucket, now);
+    if (bucket.tokens >= cost) {
+      bucket.tokens -= cost;
+      return {
+        allowed: true,
+        remaining: Math.floor(bucket.tokens),
+        resetAt: now + Math.ceil((this._capacity - bucket.tokens) / this._rate * 1e3)
+      };
+    }
+    const tokensNeeded = cost - bucket.tokens;
+    const retryAfter = Math.ceil(tokensNeeded / this._rate * 1e3);
+    return {
+      allowed: false,
+      remaining: 0,
+      resetAt: now + retryAfter,
+      retryAfter
+    };
+  }
+  /**
+   * @zh 获取当前状态
+   * @en Get current status
+   */
+  getStatus(key) {
+    const now = Date.now();
+    const bucket = this._buckets.get(key);
+    if (!bucket) {
+      return {
+        allowed: true,
+        remaining: this._capacity,
+        resetAt: now
+      };
+    }
+    this._refillBucket(bucket, now);
+    return {
+      allowed: bucket.tokens >= 1,
+      remaining: Math.floor(bucket.tokens),
+      resetAt: now + Math.ceil((this._capacity - bucket.tokens) / this._rate * 1e3)
+    };
+  }
+  /**
+   * @zh 重置指定键
+   * @en Reset specified key
+   */
+  reset(key) {
+    this._buckets.delete(key);
+  }
+  /**
+   * @zh 清理所有记录
+   * @en Clean up all records
+   */
+  cleanup() {
+    const now = Date.now();
+    const expireThreshold = 6e4;
+    for (const [key, bucket] of this._buckets) {
+      if (now - bucket.lastUpdate > expireThreshold && bucket.tokens >= this._capacity) {
+        this._buckets.delete(key);
+      }
+    }
+  }
+  /**
+   * @zh 获取或创建桶
+   * @en Get or create bucket
+   */
+  _getOrCreateBucket(key, now) {
+    let bucket = this._buckets.get(key);
+    if (!bucket) {
+      bucket = {
+        tokens: this._capacity,
+        lastUpdate: now
+      };
+      this._buckets.set(key, bucket);
+    }
+    return bucket;
+  }
+  /**
+   * @zh 补充令牌
+   * @en Refill tokens
+   */
+  _refillBucket(bucket, now) {
+    const elapsed = now - bucket.lastUpdate;
+    const tokensToAdd = elapsed / 1e3 * this._rate;
+    bucket.tokens = Math.min(this._capacity, bucket.tokens + tokensToAdd);
+    bucket.lastUpdate = now;
+  }
+};
+__name(_TokenBucketStrategy, "TokenBucketStrategy");
+var TokenBucketStrategy = _TokenBucketStrategy;
+function createTokenBucketStrategy(config) {
+  return new TokenBucketStrategy(config);
+}
+__name(createTokenBucketStrategy, "createTokenBucketStrategy");
+
+// src/ratelimit/strategies/SlidingWindow.ts
+var _SlidingWindowStrategy = class _SlidingWindowStrategy {
+  /**
+   * @zh 创建滑动窗口策略
+   * @en Create sliding window strategy
+   *
+   * @param config - @zh 配置 @en Configuration
+   * @param config.rate - @zh 每秒允许的请求数 @en Requests allowed per second
+   * @param config.capacity - @zh 窗口容量 @en Window capacity
+   */
+  constructor(config) {
+    __publicField(this, "name", "sliding-window");
+    __publicField(this, "_rate");
+    __publicField(this, "_capacity");
+    __publicField(this, "_windowMs");
+    __publicField(this, "_windows", /* @__PURE__ */ new Map());
+    this._rate = config.rate;
+    this._capacity = config.capacity;
+    this._windowMs = 1e3;
+  }
+  /**
+   * @zh 尝试消费配额
+   * @en Try to consume quota
+   */
+  consume(key, cost = 1) {
+    const now = Date.now();
+    const window = this._getOrCreateWindow(key);
+    this._cleanExpiredTimestamps(window, now);
+    const currentCount = window.timestamps.length;
+    if (currentCount + cost <= this._capacity) {
+      for (let i = 0; i < cost; i++) {
+        window.timestamps.push(now);
+      }
+      return {
+        allowed: true,
+        remaining: this._capacity - window.timestamps.length,
+        resetAt: this._getResetAt(window, now)
+      };
+    }
+    const oldestTimestamp = window.timestamps[0] || now;
+    const retryAfter = Math.max(0, oldestTimestamp + this._windowMs - now);
+    return {
+      allowed: false,
+      remaining: 0,
+      resetAt: oldestTimestamp + this._windowMs,
+      retryAfter
+    };
+  }
+  /**
+   * @zh 获取当前状态
+   * @en Get current status
+   */
+  getStatus(key) {
+    const now = Date.now();
+    const window = this._windows.get(key);
+    if (!window) {
+      return {
+        allowed: true,
+        remaining: this._capacity,
+        resetAt: now + this._windowMs
+      };
+    }
+    this._cleanExpiredTimestamps(window, now);
+    const remaining = Math.max(0, this._capacity - window.timestamps.length);
+    return {
+      allowed: remaining > 0,
+      remaining,
+      resetAt: this._getResetAt(window, now)
+    };
+  }
+  /**
+   * @zh 重置指定键
+   * @en Reset specified key
+   */
+  reset(key) {
+    this._windows.delete(key);
+  }
+  /**
+   * @zh 清理所有过期记录
+   * @en Clean up all expired records
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, window] of this._windows) {
+      this._cleanExpiredTimestamps(window, now);
+      if (window.timestamps.length === 0) {
+        this._windows.delete(key);
+      }
+    }
+  }
+  /**
+   * @zh 获取或创建窗口
+   * @en Get or create window
+   */
+  _getOrCreateWindow(key) {
+    let window = this._windows.get(key);
+    if (!window) {
+      window = {
+        timestamps: []
+      };
+      this._windows.set(key, window);
+    }
+    return window;
+  }
+  /**
+   * @zh 清理过期的时间戳
+   * @en Clean expired timestamps
+   */
+  _cleanExpiredTimestamps(window, now) {
+    const cutoff = now - this._windowMs;
+    window.timestamps = window.timestamps.filter((ts) => ts > cutoff);
+  }
+  /**
+   * @zh 获取重置时间
+   * @en Get reset time
+   */
+  _getResetAt(window, now) {
+    if (window.timestamps.length === 0) {
+      return now + this._windowMs;
+    }
+    return window.timestamps[0] + this._windowMs;
+  }
+};
+__name(_SlidingWindowStrategy, "SlidingWindowStrategy");
+var SlidingWindowStrategy = _SlidingWindowStrategy;
+function createSlidingWindowStrategy(config) {
+  return new SlidingWindowStrategy(config);
+}
+__name(createSlidingWindowStrategy, "createSlidingWindowStrategy");
+
+// src/ratelimit/strategies/FixedWindow.ts
+var _FixedWindowStrategy = class _FixedWindowStrategy {
+  /**
+   * @zh 创建固定窗口策略
+   * @en Create fixed window strategy
+   *
+   * @param config - @zh 配置 @en Configuration
+   * @param config.rate - @zh 每秒允许的请求数 @en Requests allowed per second
+   * @param config.capacity - @zh 窗口容量 @en Window capacity
+   */
+  constructor(config) {
+    __publicField(this, "name", "fixed-window");
+    __publicField(this, "_rate");
+    __publicField(this, "_capacity");
+    __publicField(this, "_windowMs");
+    __publicField(this, "_windows", /* @__PURE__ */ new Map());
+    this._rate = config.rate;
+    this._capacity = config.capacity;
+    this._windowMs = 1e3;
+  }
+  /**
+   * @zh 尝试消费配额
+   * @en Try to consume quota
+   */
+  consume(key, cost = 1) {
+    const now = Date.now();
+    const window = this._getOrCreateWindow(key, now);
+    this._maybeResetWindow(window, now);
+    if (window.count + cost <= this._capacity) {
+      window.count += cost;
+      return {
+        allowed: true,
+        remaining: this._capacity - window.count,
+        resetAt: window.windowStart + this._windowMs
+      };
+    }
+    const retryAfter = window.windowStart + this._windowMs - now;
+    return {
+      allowed: false,
+      remaining: 0,
+      resetAt: window.windowStart + this._windowMs,
+      retryAfter: Math.max(0, retryAfter)
+    };
+  }
+  /**
+   * @zh 获取当前状态
+   * @en Get current status
+   */
+  getStatus(key) {
+    const now = Date.now();
+    const window = this._windows.get(key);
+    if (!window) {
+      return {
+        allowed: true,
+        remaining: this._capacity,
+        resetAt: this._getWindowStart(now) + this._windowMs
+      };
+    }
+    this._maybeResetWindow(window, now);
+    const remaining = Math.max(0, this._capacity - window.count);
+    return {
+      allowed: remaining > 0,
+      remaining,
+      resetAt: window.windowStart + this._windowMs
+    };
+  }
+  /**
+   * @zh 重置指定键
+   * @en Reset specified key
+   */
+  reset(key) {
+    this._windows.delete(key);
+  }
+  /**
+   * @zh 清理所有过期记录
+   * @en Clean up all expired records
+   */
+  cleanup() {
+    const now = Date.now();
+    const currentWindowStart = this._getWindowStart(now);
+    for (const [key, window] of this._windows) {
+      if (window.windowStart < currentWindowStart - this._windowMs) {
+        this._windows.delete(key);
+      }
+    }
+  }
+  /**
+   * @zh 获取或创建窗口
+   * @en Get or create window
+   */
+  _getOrCreateWindow(key, now) {
+    let window = this._windows.get(key);
+    if (!window) {
+      window = {
+        count: 0,
+        windowStart: this._getWindowStart(now)
+      };
+      this._windows.set(key, window);
+    }
+    return window;
+  }
+  /**
+   * @zh 如果需要则重置窗口
+   * @en Reset window if needed
+   */
+  _maybeResetWindow(window, now) {
+    const currentWindowStart = this._getWindowStart(now);
+    if (window.windowStart < currentWindowStart) {
+      window.count = 0;
+      window.windowStart = currentWindowStart;
+    }
+  }
+  /**
+   * @zh 获取窗口开始时间
+   * @en Get window start time
+   */
+  _getWindowStart(now) {
+    return Math.floor(now / this._windowMs) * this._windowMs;
+  }
+};
+__name(_FixedWindowStrategy, "FixedWindowStrategy");
+var FixedWindowStrategy = _FixedWindowStrategy;
+function createFixedWindowStrategy(config) {
+  return new FixedWindowStrategy(config);
+}
+__name(createFixedWindowStrategy, "createFixedWindowStrategy");
+
+// src/ratelimit/context.ts
+var _RateLimitContext = class _RateLimitContext {
+  /**
+   * @zh 创建速率限制上下文
+   * @en Create rate limit context
+   *
+   * @param key - @zh 限流键（通常是玩家ID）@en Rate limit key (usually player ID)
+   * @param globalStrategy - @zh 全局限流策略 @en Global rate limit strategy
+   */
+  constructor(key, globalStrategy) {
+    __publicField(this, "_key");
+    __publicField(this, "_globalStrategy");
+    __publicField(this, "_messageStrategies", /* @__PURE__ */ new Map());
+    __publicField(this, "_consecutiveLimitCount", 0);
+    this._key = key;
+    this._globalStrategy = globalStrategy;
+  }
+  /**
+   * @zh 获取连续被限流次数
+   * @en Get consecutive limit count
+   */
+  get consecutiveLimitCount() {
+    return this._consecutiveLimitCount;
+  }
+  /**
+   * @zh 检查是否允许（不消费）
+   * @en Check if allowed (without consuming)
+   */
+  check(messageType) {
+    if (messageType && this._messageStrategies.has(messageType)) {
+      return this._messageStrategies.get(messageType).getStatus(this._key);
+    }
+    return this._globalStrategy.getStatus(this._key);
+  }
+  /**
+   * @zh 消费配额
+   * @en Consume quota
+   */
+  consume(messageType, cost = 1) {
+    let result;
+    if (messageType && this._messageStrategies.has(messageType)) {
+      result = this._messageStrategies.get(messageType).consume(this._key, cost);
+    } else {
+      result = this._globalStrategy.consume(this._key, cost);
+    }
+    if (result.allowed) {
+      this._consecutiveLimitCount = 0;
+    } else {
+      this._consecutiveLimitCount++;
+    }
+    return result;
+  }
+  /**
+   * @zh 重置限流状态
+   * @en Reset rate limit status
+   */
+  reset(messageType) {
+    if (messageType) {
+      if (this._messageStrategies.has(messageType)) {
+        this._messageStrategies.get(messageType).reset(this._key);
+      }
+    } else {
+      this._globalStrategy.reset(this._key);
+      for (const strategy of this._messageStrategies.values()) {
+        strategy.reset(this._key);
+      }
+    }
+  }
+  /**
+   * @zh 重置连续限流计数
+   * @en Reset consecutive limit count
+   */
+  resetConsecutiveCount() {
+    this._consecutiveLimitCount = 0;
+  }
+  /**
+   * @zh 为特定消息类型设置独立的限流策略
+   * @en Set independent rate limit strategy for specific message type
+   *
+   * @param messageType - @zh 消息类型 @en Message type
+   * @param strategy - @zh 限流策略 @en Rate limit strategy
+   */
+  setMessageStrategy(messageType, strategy) {
+    this._messageStrategies.set(messageType, strategy);
+  }
+  /**
+   * @zh 移除特定消息类型的限流策略
+   * @en Remove rate limit strategy for specific message type
+   *
+   * @param messageType - @zh 消息类型 @en Message type
+   */
+  removeMessageStrategy(messageType) {
+    this._messageStrategies.delete(messageType);
+  }
+  /**
+   * @zh 检查是否有特定消息类型的限流策略
+   * @en Check if has rate limit strategy for specific message type
+   *
+   * @param messageType - @zh 消息类型 @en Message type
+   */
+  hasMessageStrategy(messageType) {
+    return this._messageStrategies.has(messageType);
+  }
+};
+__name(_RateLimitContext, "RateLimitContext");
+var RateLimitContext = _RateLimitContext;
+
+// src/ratelimit/decorators/rateLimit.ts
+var RATE_LIMIT_METADATA_KEY = /* @__PURE__ */ Symbol("rateLimitMetadata");
+function getRateLimitMetadata(target, messageType) {
+  const metadataMap = target[RATE_LIMIT_METADATA_KEY];
+  return metadataMap?.get(messageType);
+}
+__name(getRateLimitMetadata, "getRateLimitMetadata");
+function setRateLimitMetadata(target, messageType, metadata) {
+  if (!target[RATE_LIMIT_METADATA_KEY]) {
+    target[RATE_LIMIT_METADATA_KEY] = /* @__PURE__ */ new Map();
+  }
+  const metadataMap = target[RATE_LIMIT_METADATA_KEY];
+  const existing = metadataMap.get(messageType) ?? {
+    enabled: true
+  };
+  metadataMap.set(messageType, {
+    ...existing,
+    ...metadata
+  });
+}
+__name(setRateLimitMetadata, "setRateLimitMetadata");
+function getMessageTypeFromMethod(target, methodName) {
+  for (const sym of Object.getOwnPropertySymbols(target.constructor)) {
+    const desc = Object.getOwnPropertyDescriptor(target.constructor, sym);
+    if (desc?.value && Array.isArray(desc.value)) {
+      for (const handler of desc.value) {
+        if (handler.method === methodName) {
+          return handler.type;
+        }
+      }
+    }
+  }
+  const handlers = target.constructor[/* @__PURE__ */ Symbol.for("messageHandlers")];
+  if (handlers) {
+    for (const handler of handlers) {
+      if (handler.method === methodName) {
+        return handler.type;
+      }
+    }
+  }
+  return void 0;
+}
+__name(getMessageTypeFromMethod, "getMessageTypeFromMethod");
+function rateLimit(config) {
+  return function(target, propertyKey, descriptor) {
+    const methodName = String(propertyKey);
+    queueMicrotask(() => {
+      const msgType = getMessageTypeFromMethod(target, methodName);
+      if (msgType) {
+        setRateLimitMetadata(target, msgType, {
+          enabled: true,
+          config
+        });
+      }
+    });
+    if (!target.hasOwnProperty(RATE_LIMIT_METADATA_KEY)) {
+      Object.defineProperty(target, RATE_LIMIT_METADATA_KEY, {
+        value: /* @__PURE__ */ new Map(),
+        writable: false,
+        enumerable: false
+      });
+    }
+    return descriptor;
+  };
+}
+__name(rateLimit, "rateLimit");
+function noRateLimit() {
+  return function(target, propertyKey, descriptor) {
+    const methodName = String(propertyKey);
+    queueMicrotask(() => {
+      const msgType = getMessageTypeFromMethod(target, methodName);
+      if (msgType) {
+        setRateLimitMetadata(target, msgType, {
+          enabled: false,
+          exempt: true
+        });
+      }
+    });
+    return descriptor;
+  };
+}
+__name(noRateLimit, "noRateLimit");
+function rateLimitMessage(messageType, config) {
+  return function(target, propertyKey, descriptor) {
+    setRateLimitMetadata(target, messageType, {
+      enabled: true,
+      config
+    });
+    return descriptor;
+  };
+}
+__name(rateLimitMessage, "rateLimitMessage");
+function noRateLimitMessage(messageType) {
+  return function(target, propertyKey, descriptor) {
+    setRateLimitMetadata(target, messageType, {
+      enabled: false,
+      exempt: true
+    });
+    return descriptor;
+  };
+}
+__name(noRateLimitMessage, "noRateLimitMessage");
+
+// src/ratelimit/mixin/withRateLimit.ts
+var PLAYER_RATE_LIMIT_CONTEXT = /* @__PURE__ */ Symbol("playerRateLimitContext");
+function createStrategy(config) {
+  const rate = config.messagesPerSecond ?? 10;
+  const capacity = config.burstSize ?? rate * 2;
+  switch (config.strategy) {
+    case "sliding-window":
+      return new SlidingWindowStrategy({
+        rate,
+        capacity
+      });
+    case "fixed-window":
+      return new FixedWindowStrategy({
+        rate,
+        capacity
+      });
+    case "token-bucket":
+    default:
+      return new TokenBucketStrategy({
+        rate,
+        capacity
+      });
+  }
+}
+__name(createStrategy, "createStrategy");
+function getPlayerRateLimitContext(player) {
+  const data = player;
+  return data[PLAYER_RATE_LIMIT_CONTEXT] ?? null;
+}
+__name(getPlayerRateLimitContext, "getPlayerRateLimitContext");
+function setPlayerRateLimitContext(player, context) {
+  const data = player;
+  data[PLAYER_RATE_LIMIT_CONTEXT] = context;
+  Object.defineProperty(player, "rateLimit", {
+    get: /* @__PURE__ */ __name(() => data[PLAYER_RATE_LIMIT_CONTEXT], "get"),
+    enumerable: true,
+    configurable: false
+  });
+}
+__name(setPlayerRateLimitContext, "setPlayerRateLimitContext");
+function withRateLimit(Base, config = {}) {
+  var _a;
+  const { messagesPerSecond = 10, burstSize = 20, strategy = "token-bucket", onLimited, disconnectOnLimit = false, maxConsecutiveLimits = 0, getKey = /* @__PURE__ */ __name((player) => player.id, "getKey"), cleanupInterval = 6e4 } = config;
+  let RateLimitRoom = (_a = class extends Base {
+    constructor(...args) {
+      super(...args);
+      __publicField(this, "_rateLimitStrategy");
+      __publicField(this, "_playerContexts", /* @__PURE__ */ new WeakMap());
+      __publicField(this, "_cleanupTimer", null);
+      __publicField(this, "_messageStrategies", /* @__PURE__ */ new Map());
+      this._rateLimitStrategy = createStrategy({
+        messagesPerSecond,
+        burstSize,
+        strategy
+      });
+      this._startCleanup();
+      this._initMessageStrategies();
+    }
+    /**
+     * @zh 全局速率限制策略
+     * @en Global rate limit strategy
+     */
+    get rateLimitStrategy() {
+      return this._rateLimitStrategy;
+    }
+    /**
+     * @zh 获取玩家的速率限制上下文
+     * @en Get rate limit context for player
+     */
+    getRateLimitContext(player) {
+      return this._playerContexts.get(player) ?? null;
+    }
+    /**
+     * @internal
+     * @zh 重写消息处理以添加速率限制检查
+     * @en Override message handling to add rate limit check
+     */
+    _handleMessage(type, data, playerId) {
+      const player = this.getPlayer(playerId);
+      if (!player) return;
+      let context = this._playerContexts.get(player);
+      if (!context) {
+        context = this._createPlayerContext(player);
+      }
+      const metadata = this._getMessageMetadata(type);
+      if (metadata?.exempt) {
+        super._handleMessage(type, data, playerId);
+        return;
+      }
+      const cost = metadata?.config?.cost ?? 1;
+      let result;
+      if (metadata?.config && (metadata.config.messagesPerSecond || metadata.config.burstSize)) {
+        if (!context.hasMessageStrategy(type)) {
+          const msgStrategy = createStrategy({
+            messagesPerSecond: metadata.config.messagesPerSecond ?? messagesPerSecond,
+            burstSize: metadata.config.burstSize ?? burstSize,
+            strategy
+          });
+          context.setMessageStrategy(type, msgStrategy);
+        }
+        result = context.consume(type, cost);
+      } else {
+        result = context.consume(void 0, cost);
+      }
+      if (!result.allowed) {
+        this._handleRateLimited(player, type, result, context);
+        return;
+      }
+      super._handleMessage(type, data, playerId);
+    }
+    /**
+     * @internal
+     * @zh 重写 _addPlayer 以初始化速率限制上下文
+     * @en Override _addPlayer to initialize rate limit context
+     */
+    async _addPlayer(id, conn) {
+      const player = await super._addPlayer(id, conn);
+      if (player) {
+        this._createPlayerContext(player);
+      }
+      return player;
+    }
+    /**
+     * @internal
+     * @zh 重写 _removePlayer 以清理速率限制上下文
+     * @en Override _removePlayer to cleanup rate limit context
+     */
+    async _removePlayer(id, reason) {
+      const player = this.getPlayer(id);
+      if (player) {
+        const context = this._playerContexts.get(player);
+        if (context) {
+          context.reset();
+        }
+        this._playerContexts.delete(player);
+      }
+      await super._removePlayer(id, reason);
+    }
+    /**
+     * @zh 重写 dispose 以清理定时器
+     * @en Override dispose to cleanup timer
+     */
+    dispose() {
+      this._stopCleanup();
+      super.dispose();
+    }
+    /**
+     * @zh 创建玩家的速率限制上下文
+     * @en Create rate limit context for player
+     */
+    _createPlayerContext(player) {
+      const key = getKey(player);
+      const context = new RateLimitContext(key, this._rateLimitStrategy);
+      this._playerContexts.set(player, context);
+      setPlayerRateLimitContext(player, context);
+      return context;
+    }
+    /**
+     * @zh 处理被限流的情况
+     * @en Handle rate limited situation
+     */
+    _handleRateLimited(player, messageType, result, context) {
+      if (this.onRateLimited) {
+        this.onRateLimited(player, messageType, result);
+      }
+      onLimited?.(player, messageType, result);
+      if (disconnectOnLimit) {
+        this.kick(player, "rate_limited");
+        return;
+      }
+      if (maxConsecutiveLimits > 0 && context.consecutiveLimitCount >= maxConsecutiveLimits) {
+        this.kick(player, "too_many_rate_limits");
+      }
+    }
+    /**
+     * @zh 获取消息的元数据
+     * @en Get message metadata
+     */
+    _getMessageMetadata(type) {
+      return getRateLimitMetadata(this.constructor.prototype, type);
+    }
+    /**
+     * @zh 初始化消息策略（从装饰器元数据）
+     * @en Initialize message strategies (from decorator metadata)
+     */
+    _initMessageStrategies() {
+      const metadataMap = this.constructor.prototype[RATE_LIMIT_METADATA_KEY];
+      if (metadataMap instanceof Map) {
+        for (const [msgType, metadata] of metadataMap) {
+          if (metadata.config && (metadata.config.messagesPerSecond || metadata.config.burstSize)) {
+            const msgStrategy = createStrategy({
+              messagesPerSecond: metadata.config.messagesPerSecond ?? messagesPerSecond,
+              burstSize: metadata.config.burstSize ?? burstSize,
+              strategy
+            });
+            this._messageStrategies.set(msgType, msgStrategy);
+          }
+        }
+      }
+    }
+    /**
+     * @zh 开始清理定时器
+     * @en Start cleanup timer
+     */
+    _startCleanup() {
+      if (cleanupInterval > 0) {
+        this._cleanupTimer = setInterval(() => {
+          this._rateLimitStrategy.cleanup();
+          for (const strategy2 of this._messageStrategies.values()) {
+            strategy2.cleanup();
+          }
+        }, cleanupInterval);
+      }
+    }
+    /**
+     * @zh 停止清理定时器
+     * @en Stop cleanup timer
+     */
+    _stopCleanup() {
+      if (this._cleanupTimer) {
+        clearInterval(this._cleanupTimer);
+        this._cleanupTimer = null;
+      }
+    }
+  }, __name(_a, "RateLimitRoom"), _a);
+  return RateLimitRoom;
+}
+__name(withRateLimit, "withRateLimit");
+
+export { FixedWindowStrategy, RATE_LIMIT_METADATA_KEY, RateLimitContext, SlidingWindowStrategy, TokenBucketStrategy, createFixedWindowStrategy, createSlidingWindowStrategy, createTokenBucketStrategy, getPlayerRateLimitContext, getRateLimitMetadata, noRateLimit, noRateLimitMessage, rateLimit, rateLimitMessage, withRateLimit };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map