@ensnode/ensnode-sdk 1.3.0 → 1.3.1

package/dist/index.cjs

@@ -793,183 +793,67 @@ function addDuration(timestamp, duration) {
   return deserializeUnixTimestamp(timestamp + duration, "UnixTimestamp");
 }
 
-// src/shared/cache/background-revalidation-scheduler.ts
-var BackgroundRevalidationScheduler = class {
-  activeSchedules = /* @__PURE__ */ new Map();
-  /**
-   * Schedule a revalidation function to run on a recurring interval.
-   *
-   * @param config Configuration object for the schedule
-   * @returns The revalidate function that can be passed to `cancel()` to stop the schedule
-   */
-  schedule(config) {
-    const { revalidate, interval, initialDelay = 0, onError } = config;
-    if (this.activeSchedules.has(revalidate)) {
-      return revalidate;
+// src/shared/cache/swr-cache.ts
+var SWRCache = class {
+  constructor(options) {
+    this.options = options;
+    if (options.proactiveRevalidationInterval) {
+      this.backgroundInterval = setInterval(
+        () => this.revalidate(),
+        (0, import_date_fns.secondsToMilliseconds)(options.proactiveRevalidationInterval)
+      );
     }
-    const metadata = {
-      config,
-      timeoutId: null,
-      inProgress: false
-    };
-    this.activeSchedules.set(revalidate, metadata);
-    const executeRevalidation = async () => {
-      if (metadata.inProgress) return;
-      metadata.inProgress = true;
-      try {
-        await revalidate();
-      } catch (error) {
-        onError?.(error);
-      } finally {
-        metadata.inProgress = false;
-      }
-    };
-    const scheduleNext = () => {
-      if (!this.activeSchedules.has(revalidate)) return;
-      metadata.timeoutId = setTimeout(() => {
-        if (this.activeSchedules.has(revalidate)) {
-          executeRevalidation().then(() => scheduleNext());
-        }
-      }, interval);
-    };
-    if (initialDelay > 0) {
-      metadata.timeoutId = setTimeout(() => {
-        if (this.activeSchedules.has(revalidate)) {
-          executeRevalidation().then(() => scheduleNext());
+    if (options.proactivelyInitialize) this.revalidate();
+  }
+  cache = null;
+  inProgressRevalidate = null;
+  backgroundInterval = null;
+  async revalidate() {
+    if (!this.inProgressRevalidate) {
+      this.inProgressRevalidate = this.options.fn().then((result) => {
+        this.cache = {
+          result,
+          updatedAt: (0, import_getUnixTime.getUnixTime)(/* @__PURE__ */ new Date())
+        };
+      }).catch((error) => {
+        if (!this.cache) {
+          this.cache = {
+            // ensure thrown value is always an Error instance
+            result: error instanceof Error ? error : new Error(String(error)),
+            updatedAt: (0, import_getUnixTime.getUnixTime)(/* @__PURE__ */ new Date())
+          };
         }
-      }, initialDelay);
-    } else {
-      scheduleNext();
+      }).finally(() => {
+        this.inProgressRevalidate = null;
+      });
     }
-    return revalidate;
+    return this.inProgressRevalidate;
   }
   /**
-   * Cancel a scheduled revalidation by its revalidate function.
+   * Read the most recently cached result from the `SWRCache`.
    *
-   * @param revalidate The revalidation function returned from `schedule()`
+   * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
+   * has never successfully returned.
    */
-  cancel(revalidate) {
-    const metadata = this.activeSchedules.get(revalidate);
-    if (!metadata) return;
-    if (metadata.timeoutId !== null) {
-      clearTimeout(metadata.timeoutId);
+  async read() {
+    if (!this.cache) await this.revalidate();
+    if (!this.cache) throw new Error("never");
+    if (durationBetween(this.cache.updatedAt, (0, import_getUnixTime.getUnixTime)(/* @__PURE__ */ new Date())) > this.options.ttl) {
+      this.revalidate();
     }
-    this.activeSchedules.delete(revalidate);
+    return this.cache.result;
   }
   /**
-   * Cancel all active schedules.
+   * Destroys the background revalidation interval, if exists.
    */
-  cancelAll() {
-    for (const [, metadata] of this.activeSchedules) {
-      if (metadata.timeoutId !== null) {
-        clearTimeout(metadata.timeoutId);
-      }
+  destroy() {
+    if (this.backgroundInterval) {
+      clearInterval(this.backgroundInterval);
+      this.backgroundInterval = null;
     }
-    this.activeSchedules.clear();
-  }
-  /**
-   * Get the count of active schedules.
-   * Useful for debugging and monitoring.
-   *
-   * @returns The number of currently active schedules
-   */
-  getActiveScheduleCount() {
-    return this.activeSchedules.size;
   }
 };
 
-// src/shared/cache/swr-cache.ts
-var bgRevalidationScheduler = new BackgroundRevalidationScheduler();
-var SWRCache = class _SWRCache {
-  options;
-  cache;
-  /**
-   * Optional promise of the current in-progress attempt to revalidate the `cache`.
-   *
-   * If null, no revalidation attempt is currently in progress.
-   * If not null, identifies the revalidation attempt that is currently in progress.
-   *
-   * Used to enforce no concurrent revalidation attempts.
-   */
-  inProgressRevalidate;
-  /**
-   * The callback function being managed by `BackgroundRevalidationScheduler`.
-   *
-   * If null, no background revalidation is scheduled.
-   * If not null, identifies the background revalidation that is currently scheduled.
-   *
-   * Used to enforce no concurrent background revalidation attempts.
-   */
-  scheduledBackgroundRevalidate;
-  constructor(options) {
-    this.cache = null;
-    this.inProgressRevalidate = null;
-    this.scheduledBackgroundRevalidate = null;
-    this.options = options;
-  }
-  /**
-   * Asynchronously create a new `SWRCache` instance.
-   *
-   * @param options - The {@link SWRCacheOptions} for the SWR cache.
-   * @returns a new `SWRCache` instance.
-   */
-  static async create(options) {
-    const cache = new _SWRCache(options);
-    if (cache.options.proactivelyInitialize) {
-      cache.readCache();
-    }
-    return cache;
-  }
-  revalidate = async () => {
-    if (this.inProgressRevalidate) {
-      return this.inProgressRevalidate;
-    }
-    return this.options.fn().then((value) => {
-      this.cache = {
-        value,
-        updatedAt: (0, import_getUnixTime.getUnixTime)(/* @__PURE__ */ new Date())
-      };
-      return this.cache;
-    }).catch(() => {
-      return null;
-    }).finally(() => {
-      this.inProgressRevalidate = null;
-      if (this.options.revalidationInterval === void 0) {
-        return;
-      }
-      if (this.scheduledBackgroundRevalidate) {
-        bgRevalidationScheduler.cancel(this.scheduledBackgroundRevalidate);
-      }
-      const backgroundRevalidate = async () => {
-        this.revalidate();
-      };
-      this.scheduledBackgroundRevalidate = bgRevalidationScheduler.schedule({
-        revalidate: backgroundRevalidate,
-        interval: (0, import_date_fns.secondsToMilliseconds)(this.options.revalidationInterval)
-      });
-    });
-  };
-  /**
-   * Read the most recently cached `CachedValue` from the `SWRCache`.
-   *
-   * @returns a `CachedValue` holding a `value` of `ValueType` that was most recently successfully returned by `fn`
-   *          or `null` if `fn` has never successfully returned and has always thrown an error,
-   */
-  readCache = async () => {
-    if (!this.cache) {
-      this.inProgressRevalidate = this.revalidate();
-      return this.inProgressRevalidate;
-    }
-    if (durationBetween(this.cache.updatedAt, (0, import_getUnixTime.getUnixTime)(/* @__PURE__ */ new Date())) <= this.options.ttl) {
-      return this.cache;
-    }
-    if (!this.inProgressRevalidate) {
-      this.inProgressRevalidate = this.revalidate();
-    }
-    return this.cache;
-  };
-};
-
 // src/shared/cache/ttl-cache.ts
 var import_getUnixTime2 = require("date-fns/getUnixTime");
 var TtlCache = class {
@@ -4179,7 +4063,11 @@ var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
 // src/resolution/resolver-records-selection.ts
 var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
 
-// src/tracing/index.ts
+// src/tracing/ens-protocol-tracing.ts
+var PROTOCOL_ATTRIBUTE_PREFIX = "ens";
+var ATTR_PROTOCOL_NAME = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol`;
+var ATTR_PROTOCOL_STEP = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step`;
+var ATTR_PROTOCOL_STEP_RESULT = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step.result`;
 var TraceableENSProtocol = /* @__PURE__ */ ((TraceableENSProtocol2) => {
   TraceableENSProtocol2["ForwardResolution"] = "forward-resolution";
   TraceableENSProtocol2["ReverseResolution"] = "reverse-resolution";
@@ -4204,8 +4092,4 @@ var ReverseResolutionProtocolStep = /* @__PURE__ */ ((ReverseResolutionProtocolS
   ReverseResolutionProtocolStep2["VerifyResolvedAddressMatchesAddress"] = "verify-resolved-address-matches-address";
   return ReverseResolutionProtocolStep2;
 })(ReverseResolutionProtocolStep || {});
-var PROTOCOL_ATTRIBUTE_PREFIX = "ens";
-var ATTR_PROTOCOL_NAME = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol`;
-var ATTR_PROTOCOL_STEP = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step`;
-var ATTR_PROTOCOL_STEP_RESULT = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step.result`;
 //# sourceMappingURL=index.cjs.map