@hashgraphonline/standards-sdk/dist/es/standards-sdk.es24.js

The Hashgraph Online Standards SDK provides a complete implementation of the Hashgraph Consensus Standards (HCS), giving developers all the tools needed to build applications on Hedera.

import { Logger } from "./standards-sdk.es22.js";
class ProgressReporter {
  constructor(options = {}) {
    this.module = options.module || "Progress";
    this.callback = options.callback;
    this.logger = options.logger || new Logger({
      level: "info",
      module: "ProgressReporter"
    });
    this.logProgress = options.logProgress ?? true;
    this.minPercent = options.minPercent ?? 0;
    this.maxPercent = options.maxPercent ?? 100;
    this.lastReportedPercent = -1;
    this.lastReportedTime = 0;
    this.throttleMs = 100;
  }
  static getInstance(options = {}) {
    if (!ProgressReporter.instance) {
      ProgressReporter.instance = new ProgressReporter(options);
    } else {
      if (options.callback) {
        ProgressReporter.instance.setCallback(options.callback);
      }
      if (options.module) {
        ProgressReporter.instance.setModule(options.module);
      }
      if (options.logger) {
        ProgressReporter.instance.setLogger(options.logger);
      }
      if (options.minPercent !== void 0) {
        ProgressReporter.instance.setMinPercent(options.minPercent);
      }
      if (options.maxPercent !== void 0) {
        ProgressReporter.instance.setMaxPercent(options.maxPercent);
      }
    }
    return ProgressReporter.instance;
  }
  setCallback(callback) {
    this.callback = callback;
  }
  setModule(module) {
    this.module = module;
  }
  setLogger(logger) {
    this.logger = logger;
  }
  setMinPercent(minPercent) {
    this.minPercent = minPercent;
  }
  setMaxPercent(maxPercent) {
    this.maxPercent = maxPercent;
  }
  createSubProgress(options) {
    const subReporter = new ProgressReporter({
      module: this.module,
      logger: this.logger,
      logProgress: this.logProgress,
      minPercent: options.minPercent,
      maxPercent: options.maxPercent
    });
    const logPrefix = options.logPrefix || "";
    subReporter.setCallback((data) => {
      const scaledPercent = this.scalePercent(
        data.progressPercent,
        options.minPercent,
        options.maxPercent
      );
      let formattedMessage = data.message;
      if (logPrefix && !formattedMessage.startsWith(logPrefix)) {
        formattedMessage = `${logPrefix}: ${formattedMessage}`;
      }
      this.report({
        stage: data.stage,
        message: formattedMessage,
        progressPercent: scaledPercent,
        details: data.details
      });
    });
    return subReporter;
  }
  report(data) {
    const rawPercent = data.progressPercent;
    const percent = Math.max(0, Math.min(100, rawPercent));
    const scaledPercent = this.scalePercent(percent, 0, 100);
    const now = Date.now();
    if (scaledPercent === this.lastReportedPercent && now - this.lastReportedTime < this.throttleMs && data.stage !== "completed" && data.stage !== "failed") {
      return;
    }
    this.lastReportedPercent = scaledPercent;
    this.lastReportedTime = now;
    const progressData = {
      ...data,
      progressPercent: scaledPercent
    };
    if (this.logProgress) {
      this.logger.debug(
        `[${this.module}] [${data.stage.toUpperCase()}] ${data.message} (${scaledPercent.toFixed(1)}%)`,
        data.details
      );
    }
    if (this.callback) {
      try {
        this.callback(progressData);
      } catch (err) {
        this.logger.warn(`Error in progress callback: ${err}`);
      }
    }
  }
  scalePercent(percent, sourceMin, sourceMax) {
    const range = this.maxPercent - this.minPercent;
    const sourceRange = sourceMax - sourceMin;
    const scaleFactor = range / sourceRange;
    return this.minPercent + (percent - sourceMin) * scaleFactor;
  }
  preparing(message, percent, details) {
    this.report({
      stage: "preparing",
      message,
      progressPercent: percent,
      details
    });
  }
  submitting(message, percent, details) {
    this.report({
      stage: "submitting",
      message,
      progressPercent: percent,
      details
    });
  }
  confirming(message, percent, details) {
    this.report({
      stage: "confirming",
      message,
      progressPercent: percent,
      details
    });
  }
  verifying(message, percent, details) {
    this.report({
      stage: "verifying",
      message,
      progressPercent: percent,
      details
    });
  }
  completed(message, details) {
    this.report({ stage: "completed", message, progressPercent: 100, details });
  }
  failed(message, details) {
    this.report({
      stage: "failed",
      message,
      progressPercent: this.lastReportedPercent,
      details
    });
  }
}
export {
  ProgressReporter
};
//# sourceMappingURL=standards-sdk.es24.js.map