@switchbot/openapi-cli 3.1.1 → 3.2.0

package/dist/utils/retry.js

@@ -1,140 +0,0 @@
-/**
- * Retry/backoff helpers for the axios client. Kept as pure functions so
- * tests can pin attempt → delay without wall-clock sleeping.
- *
- * Backoff strategies:
- *   linear       → 1s, 2s, 3s, ... (cap 30s)
- *   exponential  → 1s, 2s, 4s, 8s, 16s (cap 30s)  [default]
- *
- * If the server returns a `Retry-After` header we always prefer it over our
- * own backoff — the API explicitly told us when to come back.
- *
- * Circuit breaker:
- *   Prevents hammering a consistently-failing endpoint. Tracks consecutive
- *   failures; when `failureThreshold` is exceeded the circuit opens and
- *   subsequent calls fail immediately (with CircuitOpenError). After
- *   `resetTimeoutMs` the circuit enters half-open state: the next call is
- *   allowed as a probe — success closes it, failure re-opens it.
- */
-const BASE_MS = 1_000;
-const MAX_MS = 30_000;
-/**
- * Parse an HTTP `Retry-After` header. Supports both the seconds form
- * ("Retry-After: 42") and the HTTP-date form ("Retry-After: Wed, 21 Oct
- * 2015 07:28:00 GMT"). Returns the delay in ms, or undefined on garbage.
- */
-export function parseRetryAfter(header, now = Date.now()) {
-    if (typeof header !== 'string')
-        return undefined;
-    const trimmed = header.trim();
-    if (!trimmed)
-        return undefined;
-    // All-digits → seconds.
-    if (/^\d+$/.test(trimmed)) {
-        const seconds = Number(trimmed);
-        if (!Number.isFinite(seconds) || seconds < 0)
-            return undefined;
-        return Math.min(seconds * 1000, MAX_MS);
-    }
-    // HTTP-date.
-    const ts = Date.parse(trimmed);
-    if (!Number.isFinite(ts))
-        return undefined;
-    const delta = ts - now;
-    if (delta <= 0)
-        return 0;
-    return Math.min(delta, MAX_MS);
-}
-/** Compute the next backoff delay (ms) for a given attempt index (0-based). */
-export function computeBackoff(attempt, strategy) {
-    const safe = Math.max(0, attempt);
-    if (strategy === 'linear') {
-        return Math.min((safe + 1) * BASE_MS, MAX_MS);
-    }
-    // exponential
-    return Math.min(BASE_MS * Math.pow(2, safe), MAX_MS);
-}
-/** Resolve the delay to use before the next retry, preferring Retry-After. */
-export function nextRetryDelayMs(attempt, strategy, retryAfterHeader, now = Date.now()) {
-    const fromHeader = parseRetryAfter(retryAfterHeader, now);
-    if (fromHeader !== undefined)
-        return fromHeader;
-    return computeBackoff(attempt, strategy);
-}
-export function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Thrown when a call is blocked because the circuit is open.
- */
-export class CircuitOpenError extends Error {
-    circuitName;
-    nextAttemptMs;
-    constructor(circuitName, nextAttemptMs) {
-        super(`Circuit "${circuitName}" is open — too many recent failures. Next probe allowed in ${Math.ceil((nextAttemptMs - Date.now()) / 1000)}s.`);
-        this.circuitName = circuitName;
-        this.nextAttemptMs = nextAttemptMs;
-        this.name = 'CircuitOpenError';
-    }
-}
-export class CircuitBreaker {
-    name;
-    state = 'closed';
-    failures = 0;
-    lastOpenedAt = 0;
-    failureThreshold;
-    resetTimeoutMs;
-    constructor(name, opts = {}) {
-        this.name = name;
-        this.failureThreshold = opts.failureThreshold ?? 5;
-        this.resetTimeoutMs = opts.resetTimeoutMs ?? 60_000;
-    }
-    getState() {
-        this._maybeHalfOpen();
-        return this.state;
-    }
-    getStats() {
-        this._maybeHalfOpen();
-        return {
-            state: this.state,
-            failures: this.failures,
-            lastOpenedAt: this.lastOpenedAt,
-            nextProbeMs: this.state === 'open' ? this.lastOpenedAt + this.resetTimeoutMs : 0,
-        };
-    }
-    /**
-     * Check if a call is allowed. Throws `CircuitOpenError` when the circuit
-     * is open and the reset timeout hasn't elapsed. Call `recordSuccess()` or
-     * `recordFailure()` after the operation completes.
-     */
-    checkAndAllow() {
-        this._maybeHalfOpen();
-        if (this.state === 'open') {
-            throw new CircuitOpenError(this.name, this.lastOpenedAt + this.resetTimeoutMs);
-        }
-        // closed or half-open: allow the call
-    }
-    recordSuccess() {
-        this.failures = 0;
-        this.state = 'closed';
-    }
-    recordFailure() {
-        this.failures++;
-        if (this.state === 'half-open' || this.failures >= this.failureThreshold) {
-            this.state = 'open';
-            this.lastOpenedAt = Date.now();
-        }
-    }
-    /** Reset to closed — useful for testing or manual recovery. */
-    reset() {
-        this.state = 'closed';
-        this.failures = 0;
-        this.lastOpenedAt = 0;
-    }
-    _maybeHalfOpen() {
-        if (this.state === 'open' &&
-            Date.now() >= this.lastOpenedAt + this.resetTimeoutMs) {
-            this.state = 'half-open';
-        }
-    }
-}

package/dist/utils/string.js

@@ -1,22 +0,0 @@
-export function levenshtein(a, b) {
-    if (a === b)
-        return 0;
-    if (a.length === 0)
-        return b.length;
-    if (b.length === 0)
-        return a.length;
-    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
-    for (let i = 1; i <= a.length; i++) {
-        let prev = i;
-        for (let j = 1; j <= b.length; j++) {
-            const val = a[i - 1] === b[j - 1] ? row[j - 1] : Math.min(row[j - 1], row[j], prev) + 1;
-            row[j - 1] = prev;
-            prev = val;
-        }
-        row[b.length] = prev;
-    }
-    return row[b.length];
-}
-export function normalizeDeviceName(s) {
-    return s.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff ]/g, ' ').replace(/\s+/g, ' ').trim();
-}

package/dist/version.js

@@ -1,4 +0,0 @@
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-const { version: VERSION } = require('../package.json');
-export { VERSION };