react-native-cos-sdk/lib/commonjs/index.js

Tencent COS XML SDK for React Native

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _reactNative = require("react-native");
var _cos_service = require("./cos_service");
var _cos_transfer = require("./cos_transfer");
var _scope_credentials = require("./credentials/scope_credentials");
var _events = require("./data_model/events");
var _errors = require("./data_model/errors");
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
const LINKING_ERROR = `The package 'react-native-cos-sdk' doesn't seem to be linked. Make sure: \n\n` + _reactNative.Platform.select({
  ios: "- You have run 'pod install'\n",
  default: ''
}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
const QCloudCosReactNative = _reactNative.NativeModules.QCloudCosReactNative ? _reactNative.NativeModules.QCloudCosReactNative : new Proxy({}, {
  get() {
    throw new Error(LINKING_ERROR);
  }
});
const CosEventEmitter = _reactNative.NativeModules.CosEventEmitter ? _reactNative.NativeModules.CosEventEmitter : new Proxy({}, {
  get() {
    throw new Error(LINKING_ERROR);
  }
});
const DEFAULT_KEY = "";
class Cos {
  constructor() {
    _defineProperty(this, "emitter", void 0);
    _defineProperty(this, "initialized", false);
    _defineProperty(this, "cosServices", void 0);
    _defineProperty(this, "cosTransfers", void 0);
    _defineProperty(this, "scopeLimitCredentialsProvider", void 0);
    _defineProperty(this, "logListeners", void 0);
    this.cosServices = new Map();
    this.cosTransfers = new Map();
    this.scopeLimitCredentialsProvider = new _scope_credentials.ScopeLimitCredentialsProvider();
    this.logListeners = new Map();
    if (_reactNative.Platform.OS === 'ios') {
      this.emitter = new _reactNative.NativeEventEmitter(CosEventEmitter);
    } else if (_reactNative.Platform.OS === 'android') {
      this.emitter = new _reactNative.NativeEventEmitter(QCloudCosReactNative);
    } else {
      this.emitter = new _reactNative.NativeEventEmitter();
    }
    this.emitter.addListener(_events.COS_EMITTER_RESULT_SUCCESS_CALLBACK, event => {
      this.getTransferManger(event.transferKey).runResultSuccessCallBack(event.callbackKey, event.headers);
    });
    this.emitter.addListener(_events.COS_EMITTER_RESULT_FAIL_CALLBACK, event => {
      this.getTransferManger(event.transferKey).runResultFailCallBack(event.callbackKey, event.clientException, event.serviceException);
    });
    this.emitter.addListener(_events.COS_EMITTER_PROGRESS_CALLBACK, event => {
      this.getTransferManger(event.transferKey).runProgressCallBack(event.callbackKey, Number(event.complete), Number(event.target));
    });
    this.emitter.addListener(_events.COS_EMITTER_STATE_CALLBACK, event => {
      this.getTransferManger(event.transferKey).runStateCallBack(event.callbackKey, event.state);
    });
    this.emitter.addListener(_events.COS_EMITTER_INIT_MULTIPLE_UPLOAD_CALLBACK, event => {
      this.getTransferManger(event.transferKey).runInitMultipleUploadCallback(event.callbackKey, event.bucket, event.key, event.uploadId);
    });
    this.emitter.addListener(_events.COS_EMITTER_LOG_CALLBACK, event => {
      var _this$logListeners$ge;
      const logEntity = JSON.parse(event.logEntityJson);
      (_this$logListeners$ge = this.logListeners.get(event.key)) === null || _this$logListeners$ge === void 0 ? void 0 : _this$logListeners$ge.call(this, logEntity);
    });
  }
  initWithPlainSecret(secretId, secretKey) {
    if (!this.initialized) {
      this.initialized = true;
      return QCloudCosReactNative.initWithPlainSecret(secretId, secretKey);
    } else {
      console.log("COS Service has been inited before.");
      return undefined;
    }
  }
  initWithSessionCredentialCallback(callback) {
    if (!this.initialized) {
      this.initialized = true;
      this.emitter.addListener(_events.COS_EMITTER_UPDATE_SESSION_CREDENTIAL, async () => {
        const credential = await callback();
        if (credential) {
          QCloudCosReactNative.updateSessionCredential(credential, null);
        }
      });
      return QCloudCosReactNative.initWithSessionCredentialCallback();
    } else {
      console.log("COS Service has been inited before.");
      return undefined;
    }
  }
  initWithScopeLimitCredentialCallback(callback) {
    if (!this.initialized) {
      this.initialized = true;
      this.emitter.addListener(_events.COS_EMITTER_UPDATE_SESSION_CREDENTIAL, async event => {
        console.log(event.stsScopesArrayJson);
        if (event.stsScopesArrayJson) {
          const credential = await this.scopeLimitCredentialsProvider.fetchScopeLimitCredentials(event.stsScopesArrayJson, callback);
          if (credential) {
            QCloudCosReactNative.updateSessionCredential(credential, event.stsScopesArrayJson);
          }
        }
      });
      return QCloudCosReactNative.initWithScopeLimitCredentialCallback();
    } else {
      console.log("COS Service has been inited before.");
      return undefined;
    }
  }

  /// 初始化自定义 DNS 解析Map
  initCustomerDNS(dnsMap) {
    return QCloudCosReactNative.initCustomerDNS(dnsMap);
  }

  /// 初始化自定义 DNS 解析器
  initCustomerDNSFetch(callback) {
    this.emitter.removeAllListeners(_events.COS_EMITTER_DNS_FETCH);
    this.emitter.addListener(_events.COS_EMITTER_DNS_FETCH, async domain => {
      const ips = await callback(domain);
      QCloudCosReactNative.setDNSFetchIps(domain, ips);
    });
    return QCloudCosReactNative.initCustomerDNSFetch();
  }
  forceInvalidationCredential() {
    this.scopeLimitCredentialsProvider.forceInvalidationScopeCredentials();
    return QCloudCosReactNative.forceInvalidationCredential();
  }
  setCloseBeacon(isCloseBeacon) {
    return QCloudCosReactNative.setCloseBeacon(isCloseBeacon);
  }
  async registerDefaultService(config) {
    await QCloudCosReactNative.registerDefaultService(config);
    let cosService = new _cos_service.CosService(DEFAULT_KEY, QCloudCosReactNative);
    this.cosServices.set(DEFAULT_KEY, cosService);
    return cosService;
  }
  async registerDefaultTransferManger(config, transferConfig) {
    await QCloudCosReactNative.registerDefaultTransferManger(config, transferConfig);
    let cosTransfer = new _cos_transfer.CosTransferManger(DEFAULT_KEY, QCloudCosReactNative);
    this.cosTransfers.set(DEFAULT_KEY, cosTransfer);
    return cosTransfer;
  }
  async registerService(key, config) {
    if (key == DEFAULT_KEY) {
      throw new _errors.IllegalArgumentError("register key cannot be empty");
    }
    await QCloudCosReactNative.registerService(key, config);
    let cosService = new _cos_service.CosService(key, QCloudCosReactNative);
    this.cosServices.set(key, cosService);
    return cosService;
  }
  async registerTransferManger(key, config, transferConfig) {
    if (key == DEFAULT_KEY) {
      throw new _errors.IllegalArgumentError("register key cannot be empty");
    }
    await QCloudCosReactNative.registerTransferManger(key, config, transferConfig);
    let cosTransfer = new _cos_transfer.CosTransferManger(key, QCloudCosReactNative);
    this.cosTransfers.set(key, cosTransfer);
    return cosTransfer;
  }
  hasDefaultService() {
    return this.cosServices.has(DEFAULT_KEY);
  }
  getDefaultService() {
    if (this.cosServices.has(DEFAULT_KEY)) {
      return this.cosServices.get(DEFAULT_KEY);
    } else {
      throw new _errors.IllegalArgumentError("default service unregistered");
    }
  }
  hasDefaultTransferManger() {
    return this.cosTransfers.has(DEFAULT_KEY);
  }
  getDefaultTransferManger() {
    if (this.cosTransfers.has(DEFAULT_KEY)) {
      return this.cosTransfers.get(DEFAULT_KEY);
    } else {
      throw new _errors.IllegalArgumentError("default transfer manger unregistered");
    }
  }
  hasService(key) {
    return this.cosServices.has(key);
  }
  getService(key) {
    if (this.cosServices.has(key)) {
      return this.cosServices.get(key);
    } else {
      throw new _errors.IllegalArgumentError(`${key} service unregistered`);
    }
  }
  hasTransferManger(key) {
    return this.cosTransfers.has(key);
  }
  getTransferManger(key) {
    if (this.cosTransfers.has(key)) {
      return this.cosTransfers.get(key);
    } else {
      throw new _errors.IllegalArgumentError(`${key} transfer manger unregistered`);
    }
  }

  /// 启用/禁用 Logcat 日志输出
  enableLogcat(enable) {
    return QCloudCosReactNative.enableLogcat(enable);
  }

  /// 启用/禁用日志文件输出
  enableLogFile(enable) {
    return QCloudCosReactNative.enableLogFile(enable);
  }

  /// 添加日志监听器
  addLogListener(key, callback) {
    this.logListeners.set(key, callback);
    return QCloudCosReactNative.addLogListener(key);
  }

  /// 移除日志监听器
  removeLogListener(key) {
    this.logListeners.delete(key);
    return QCloudCosReactNative.removeLogListener(key);
  }

  /// 设置最小日志级别
  setMinLevel(minLevel) {
    return QCloudCosReactNative.setMinLevel(minLevel);
  }

  /// 设置 Logcat 最小日志级别
  setLogcatMinLevel(minLevel) {
    return QCloudCosReactNative.setLogcatMinLevel(minLevel);
  }

  /// 设置日志文件最小级别
  setFileMinLevel(minLevel) {
    return QCloudCosReactNative.setFileMinLevel(minLevel);
  }

  /// 设置 CLS 日志最小级别
  setClsMinLevel(minLevel) {
    return QCloudCosReactNative.setClsMinLevel(minLevel);
  }

  /// 设置设备 ID
  setDeviceID(deviceID) {
    return QCloudCosReactNative.setDeviceID(deviceID);
  }

  /// 设置设备型号
  setDeviceModel(deviceModel) {
    return QCloudCosReactNative.setDeviceModel(deviceModel);
  }

  /// 设置应用版本
  setAppVersion(appVersion) {
    return QCloudCosReactNative.setAppVersion(appVersion);
  }

  /// 设置额外信息
  setExtras(extras) {
    return QCloudCosReactNative.setExtras(extras);
  }

  /// 设置日志文件加密密钥
  setLogFileEncryptionKey(key, iv) {
    const keyArray = Array.from(key); // 或 [...key]
    const ivArray = Array.from(iv);
    return QCloudCosReactNative.setLogFileEncryptionKey(keyArray, ivArray);
  }

  /// 设置匿名 CLS 通道
  setCLsChannelAnonymous(topicId, endpoint) {
    return QCloudCosReactNative.setCLsChannelAnonymous(topicId, endpoint);
  }

  /// 设置静态密钥 CLS 通道
  setCLsChannelStaticKey(topicId, endpoint, secretId, secretKey) {
    return QCloudCosReactNative.setCLsChannelStaticKey(topicId, endpoint, secretId, secretKey);
  }

  /// 设置会话凭证 CLS 通道
  setCLsChannelSessionCredential(topicId, endpoint, callback) {
    this.emitter.addListener(_events.COS_EMITTER_UPDATE_CLS_SESSION_CREDENTIAL, async () => {
      const credential = await callback();
      if (credential) {
        QCloudCosReactNative.updateCLsChannelSessionCredential(credential);
      }
    });
    return QCloudCosReactNative.setCLsChannelSessionCredential(topicId, endpoint);
  }

  /// 添加敏感信息过滤规则
  addSensitiveRule(ruleName, regex) {
    return QCloudCosReactNative.addSensitiveRule(ruleName, regex);
  }

  /// 移除敏感信息过滤规则
  removeSensitiveRule(ruleName) {
    return QCloudCosReactNative.removeSensitiveRule(ruleName);
  }
  getLogRootDir() {
    return QCloudCosReactNative.getLogRootDir();
  }
}
var _default = new Cos();
exports.default = _default;
//# sourceMappingURL=index.js.map