@ms-cloudpack/remote-cache 0.11.79 → 0.12.1

package/dist/{getListOfBlobs-EKSDNQNV.js → getListOfBlobs-TO4FMDDN.js}

@@ -8,7 +8,7 @@ const __filename = topLevelUrl.fileURLToPath(import.meta.url);
 const __dirname = topLevelPath.dirname(__filename);
 import {
   __name
-} from "./chunk-GKUS2JGY.js";
+} from "./chunk-BKTAAWO5.js";
 
 // src/getListOfBlobs.ts
 async function getListOfBlobs(containerClient, context) {

package/dist/index.js

@@ -9,6 +9,16 @@ const __dirname = topLevelPath.dirname(__filename);
 import {
   AzureNamedKeyCredential,
   BlobServiceClient,
+  init_esm as init_esm5,
+  init_esm2 as init_esm7,
+  init_esm3 as init_esm8,
+  isNamedKeyCredential,
+  isSASCredential,
+  isTokenCredential,
+  parseXML,
+  stringifyXML
+} from "./chunk-3AKZVDQW.js";
+import {
   RestError,
   ServiceClient,
   authorizeRequestOnTenantChallenge,
@@ -19,31 +29,473 @@ import {
   createSerializer,
   createTracingClient,
   init_esm,
-  init_esm2,
-  init_esm3,
-  init_esm4,
-  init_esm5,
+  init_esm3 as init_esm2,
+  init_esm4 as init_esm3,
+  init_esm5 as init_esm4,
   init_esm6,
-  init_esm7,
-  init_esm8,
-  isNamedKeyCredential,
-  isSASCredential,
-  isTokenCredential,
-  parseXML,
   randomUUID,
   serializationPolicy,
-  serializationPolicyName,
-  stringifyXML
-} from "./chunk-XII3BYIY.js";
-import {
-  require_commonjs
-} from "./chunk-MIWDHAQF.js";
-import "./chunk-BOUMQX3J.js";
-import "./chunk-HONSOHFT.js";
+  serializationPolicyName
+} from "./chunk-X63PAUN4.js";
+import "./chunk-VAAN3ZWL.js";
 import {
+  __commonJS,
   __export,
-  __name
-} from "./chunk-GKUS2JGY.js";
+  __name,
+  __require
+} from "./chunk-BKTAAWO5.js";
+
+// ../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/log.js
+var require_log = __commonJS({
+  "../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/log.js"(exports, module) {
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export2 = /* @__PURE__ */ __name((target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    }, "__export");
+    var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: /* @__PURE__ */ __name(() => from[key], "get"), enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    }, "__copyProps");
+    var __toESM = /* @__PURE__ */ __name((mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    )), "__toESM");
+    var __toCommonJS = /* @__PURE__ */ __name((mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod), "__toCommonJS");
+    var log_exports = {};
+    __export2(log_exports, {
+      log: /* @__PURE__ */ __name(() => log, "log")
+    });
+    module.exports = __toCommonJS(log_exports);
+    var import_node_os = __require("node:os");
+    var import_node_util = __toESM(__require("node:util"));
+    var import_node_process = __toESM(__require("node:process"));
+    function log(message, ...args) {
+      import_node_process.default.stderr.write(`${import_node_util.default.format(message, ...args)}${import_node_os.EOL}`);
+    }
+    __name(log, "log");
+  }
+});
+
+// ../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/debug.js"(exports, module) {
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export2 = /* @__PURE__ */ __name((target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    }, "__export");
+    var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: /* @__PURE__ */ __name(() => from[key], "get"), enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    }, "__copyProps");
+    var __toCommonJS = /* @__PURE__ */ __name((mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod), "__toCommonJS");
+    var debug_exports = {};
+    __export2(debug_exports, {
+      default: /* @__PURE__ */ __name(() => debug_default, "default")
+    });
+    module.exports = __toCommonJS(debug_exports);
+    var import_log = require_log();
+    var debugEnvVariable = typeof process !== "undefined" && process.env && process.env.DEBUG || void 0;
+    var enabledString;
+    var enabledNamespaces = [];
+    var skippedNamespaces = [];
+    var debuggers = [];
+    if (debugEnvVariable) {
+      enable(debugEnvVariable);
+    }
+    var debugObj = Object.assign(
+      (namespace) => {
+        return createDebugger(namespace);
+      },
+      {
+        enable,
+        enabled,
+        disable,
+        log: import_log.log
+      }
+    );
+    function enable(namespaces) {
+      enabledString = namespaces;
+      enabledNamespaces = [];
+      skippedNamespaces = [];
+      const namespaceList = namespaces.split(",").map((ns) => ns.trim());
+      for (const ns of namespaceList) {
+        if (ns.startsWith("-")) {
+          skippedNamespaces.push(ns.substring(1));
+        } else {
+          enabledNamespaces.push(ns);
+        }
+      }
+      for (const instance of debuggers) {
+        instance.enabled = enabled(instance.namespace);
+      }
+    }
+    __name(enable, "enable");
+    function enabled(namespace) {
+      if (namespace.endsWith("*")) {
+        return true;
+      }
+      for (const skipped of skippedNamespaces) {
+        if (namespaceMatches(namespace, skipped)) {
+          return false;
+        }
+      }
+      for (const enabledNamespace of enabledNamespaces) {
+        if (namespaceMatches(namespace, enabledNamespace)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    __name(enabled, "enabled");
+    function namespaceMatches(namespace, patternToMatch) {
+      if (patternToMatch.indexOf("*") === -1) {
+        return namespace === patternToMatch;
+      }
+      let pattern = patternToMatch;
+      if (patternToMatch.indexOf("**") !== -1) {
+        const patternParts = [];
+        let lastCharacter = "";
+        for (const character of patternToMatch) {
+          if (character === "*" && lastCharacter === "*") {
+            continue;
+          } else {
+            lastCharacter = character;
+            patternParts.push(character);
+          }
+        }
+        pattern = patternParts.join("");
+      }
+      let namespaceIndex = 0;
+      let patternIndex = 0;
+      const patternLength = pattern.length;
+      const namespaceLength = namespace.length;
+      let lastWildcard = -1;
+      let lastWildcardNamespace = -1;
+      while (namespaceIndex < namespaceLength && patternIndex < patternLength) {
+        if (pattern[patternIndex] === "*") {
+          lastWildcard = patternIndex;
+          patternIndex++;
+          if (patternIndex === patternLength) {
+            return true;
+          }
+          while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+            namespaceIndex++;
+            if (namespaceIndex === namespaceLength) {
+              return false;
+            }
+          }
+          lastWildcardNamespace = namespaceIndex;
+          namespaceIndex++;
+          patternIndex++;
+          continue;
+        } else if (pattern[patternIndex] === namespace[namespaceIndex]) {
+          patternIndex++;
+          namespaceIndex++;
+        } else if (lastWildcard >= 0) {
+          patternIndex = lastWildcard + 1;
+          namespaceIndex = lastWildcardNamespace + 1;
+          if (namespaceIndex === namespaceLength) {
+            return false;
+          }
+          while (namespace[namespaceIndex] !== pattern[patternIndex]) {
+            namespaceIndex++;
+            if (namespaceIndex === namespaceLength) {
+              return false;
+            }
+          }
+          lastWildcardNamespace = namespaceIndex;
+          namespaceIndex++;
+          patternIndex++;
+          continue;
+        } else {
+          return false;
+        }
+      }
+      const namespaceDone = namespaceIndex === namespace.length;
+      const patternDone = patternIndex === pattern.length;
+      const trailingWildCard = patternIndex === pattern.length - 1 && pattern[patternIndex] === "*";
+      return namespaceDone && (patternDone || trailingWildCard);
+    }
+    __name(namespaceMatches, "namespaceMatches");
+    function disable() {
+      const result = enabledString || "";
+      enable("");
+      return result;
+    }
+    __name(disable, "disable");
+    function createDebugger(namespace) {
+      const newDebugger = Object.assign(debug, {
+        enabled: enabled(namespace),
+        destroy,
+        log: debugObj.log,
+        namespace,
+        extend
+      });
+      function debug(...args) {
+        if (!newDebugger.enabled) {
+          return;
+        }
+        if (args.length > 0) {
+          args[0] = `${namespace} ${args[0]}`;
+        }
+        newDebugger.log(...args);
+      }
+      __name(debug, "debug");
+      debuggers.push(newDebugger);
+      return newDebugger;
+    }
+    __name(createDebugger, "createDebugger");
+    function destroy() {
+      const index = debuggers.indexOf(this);
+      if (index >= 0) {
+        debuggers.splice(index, 1);
+        return true;
+      }
+      return false;
+    }
+    __name(destroy, "destroy");
+    function extend(namespace) {
+      const newDebugger = createDebugger(`${this.namespace}:${namespace}`);
+      newDebugger.log = this.log;
+      return newDebugger;
+    }
+    __name(extend, "extend");
+    var debug_default = debugObj;
+  }
+});
+
+// ../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/logger.js
+var require_logger = __commonJS({
+  "../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/logger.js"(exports, module) {
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export2 = /* @__PURE__ */ __name((target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    }, "__export");
+    var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: /* @__PURE__ */ __name(() => from[key], "get"), enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    }, "__copyProps");
+    var __toESM = /* @__PURE__ */ __name((mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    )), "__toESM");
+    var __toCommonJS = /* @__PURE__ */ __name((mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod), "__toCommonJS");
+    var logger_exports = {};
+    __export2(logger_exports, {
+      TypeSpecRuntimeLogger: /* @__PURE__ */ __name(() => TypeSpecRuntimeLogger, "TypeSpecRuntimeLogger"),
+      createClientLogger: /* @__PURE__ */ __name(() => createClientLogger2, "createClientLogger"),
+      createLoggerContext: /* @__PURE__ */ __name(() => createLoggerContext2, "createLoggerContext"),
+      getLogLevel: /* @__PURE__ */ __name(() => getLogLevel, "getLogLevel"),
+      setLogLevel: /* @__PURE__ */ __name(() => setLogLevel, "setLogLevel")
+    });
+    module.exports = __toCommonJS(logger_exports);
+    var import_debug = __toESM(require_debug());
+    var TYPESPEC_RUNTIME_LOG_LEVELS = ["verbose", "info", "warning", "error"];
+    var levelMap = {
+      verbose: 400,
+      info: 300,
+      warning: 200,
+      error: 100
+    };
+    function patchLogMethod(parent, child) {
+      child.log = (...args) => {
+        parent.log(...args);
+      };
+    }
+    __name(patchLogMethod, "patchLogMethod");
+    function isTypeSpecRuntimeLogLevel(level) {
+      return TYPESPEC_RUNTIME_LOG_LEVELS.includes(level);
+    }
+    __name(isTypeSpecRuntimeLogLevel, "isTypeSpecRuntimeLogLevel");
+    function createLoggerContext2(options) {
+      const registeredLoggers = /* @__PURE__ */ new Set();
+      const logLevelFromEnv = typeof process !== "undefined" && process.env && process.env[options.logLevelEnvVarName] || void 0;
+      let logLevel;
+      const clientLogger = (0, import_debug.default)(options.namespace);
+      clientLogger.log = (...args) => {
+        import_debug.default.log(...args);
+      };
+      function contextSetLogLevel(level) {
+        if (level && !isTypeSpecRuntimeLogLevel(level)) {
+          throw new Error(
+            `Unknown log level '${level}'. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(",")}`
+          );
+        }
+        logLevel = level;
+        const enabledNamespaces = [];
+        for (const logger3 of registeredLoggers) {
+          if (shouldEnable(logger3)) {
+            enabledNamespaces.push(logger3.namespace);
+          }
+        }
+        import_debug.default.enable(enabledNamespaces.join(","));
+      }
+      __name(contextSetLogLevel, "contextSetLogLevel");
+      if (logLevelFromEnv) {
+        if (isTypeSpecRuntimeLogLevel(logLevelFromEnv)) {
+          contextSetLogLevel(logLevelFromEnv);
+        } else {
+          console.error(
+            `${options.logLevelEnvVarName} set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${TYPESPEC_RUNTIME_LOG_LEVELS.join(
+              ", "
+            )}.`
+          );
+        }
+      }
+      function shouldEnable(logger3) {
+        return Boolean(logLevel && levelMap[logger3.level] <= levelMap[logLevel]);
+      }
+      __name(shouldEnable, "shouldEnable");
+      function createLogger(parent, level) {
+        const logger3 = Object.assign(parent.extend(level), {
+          level
+        });
+        patchLogMethod(parent, logger3);
+        if (shouldEnable(logger3)) {
+          const enabledNamespaces = import_debug.default.disable();
+          import_debug.default.enable(enabledNamespaces + "," + logger3.namespace);
+        }
+        registeredLoggers.add(logger3);
+        return logger3;
+      }
+      __name(createLogger, "createLogger");
+      function contextGetLogLevel() {
+        return logLevel;
+      }
+      __name(contextGetLogLevel, "contextGetLogLevel");
+      function contextCreateClientLogger(namespace) {
+        const clientRootLogger = clientLogger.extend(namespace);
+        patchLogMethod(clientLogger, clientRootLogger);
+        return {
+          error: createLogger(clientRootLogger, "error"),
+          warning: createLogger(clientRootLogger, "warning"),
+          info: createLogger(clientRootLogger, "info"),
+          verbose: createLogger(clientRootLogger, "verbose")
+        };
+      }
+      __name(contextCreateClientLogger, "contextCreateClientLogger");
+      return {
+        setLogLevel: contextSetLogLevel,
+        getLogLevel: contextGetLogLevel,
+        createClientLogger: contextCreateClientLogger,
+        logger: clientLogger
+      };
+    }
+    __name(createLoggerContext2, "createLoggerContext");
+    var context = createLoggerContext2({
+      logLevelEnvVarName: "TYPESPEC_RUNTIME_LOG_LEVEL",
+      namespace: "typeSpecRuntime"
+    });
+    var TypeSpecRuntimeLogger = context.logger;
+    function setLogLevel(logLevel) {
+      context.setLogLevel(logLevel);
+    }
+    __name(setLogLevel, "setLogLevel");
+    function getLogLevel() {
+      return context.getLogLevel();
+    }
+    __name(getLogLevel, "getLogLevel");
+    function createClientLogger2(namespace) {
+      return context.createClientLogger(namespace);
+    }
+    __name(createClientLogger2, "createClientLogger");
+  }
+});
+
+// ../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/internal.js
+var require_internal = __commonJS({
+  "../../node_modules/.store/@typespec-ts-http-runtime-npm-0.3.5-d16263195f/package/dist/commonjs/logger/internal.js"(exports, module) {
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export2 = /* @__PURE__ */ __name((target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    }, "__export");
+    var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: /* @__PURE__ */ __name(() => from[key], "get"), enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    }, "__copyProps");
+    var __toCommonJS = /* @__PURE__ */ __name((mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod), "__toCommonJS");
+    var internal_exports = {};
+    __export2(internal_exports, {
+      createLoggerContext: /* @__PURE__ */ __name(() => import_logger4.createLoggerContext, "createLoggerContext")
+    });
+    module.exports = __toCommonJS(internal_exports);
+    var import_logger4 = require_logger();
+  }
+});
+
+// ../../node_modules/.store/@azure-logger-npm-1.3.0-d53081e040/package/dist/commonjs/index.js
+var require_commonjs = __commonJS({
+  "../../node_modules/.store/@azure-logger-npm-1.3.0-d53081e040/package/dist/commonjs/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AzureLogger = void 0;
+    exports.setLogLevel = setLogLevel;
+    exports.getLogLevel = getLogLevel;
+    exports.createClientLogger = createClientLogger2;
+    var logger_1 = require_internal();
+    var context = (0, logger_1.createLoggerContext)({
+      logLevelEnvVarName: "AZURE_LOG_LEVEL",
+      namespace: "azure"
+    });
+    exports.AzureLogger = context.logger;
+    function setLogLevel(level) {
+      context.setLogLevel(level);
+    }
+    __name(setLogLevel, "setLogLevel");
+    function getLogLevel() {
+      return context.getLogLevel();
+    }
+    __name(getLogLevel, "getLogLevel");
+    function createClientLogger2(namespace) {
+      return context.createClientLogger(namespace);
+    }
+    __name(createClientLogger2, "createClientLogger");
+  }
+});
 
 // src/registerAzureLogger.ts
 import EventEmitter from "events";
@@ -152,10 +604,10 @@ async function createRemoteCacheClient(params) {
   const { container, loginMethod, storageAccount, cachePath, tenantId } = options;
   const { telemetryClient } = context;
   return telemetryClient.tracer.startActiveSpan("CREATE_REMOTE_CACHE_CLIENT", async () => {
-    const { getCredential } = await import("./getCredential-Y4HWJOQE.js");
-    const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-S655UBV6.js");
-    const { ReporterDecorator } = await import("./ReporterDecorator-DNRF2TDF.js");
-    const { getListOfBlobs } = await import("./getListOfBlobs-EKSDNQNV.js");
+    const { getCredential } = await import("./getCredential-SDHKBJNP.js");
+    const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-IQQATZ4C.js");
+    const { ReporterDecorator } = await import("./ReporterDecorator-TXYL7NGD.js");
+    const { getListOfBlobs } = await import("./getListOfBlobs-TO4FMDDN.js");
     const credential = await getCredential(
       { loginMethod, cachePath, tenantId },
       { ...context, azureLogger: azureLogEventHandler }
@@ -4301,7 +4753,7 @@ async function createAppRegistryClient(params) {
   const { context, options } = params;
   const { loginMethod, cachePath, tenantId = defaultTenantId, storageAccount = defaultStorageAccount } = options;
   const azureLogEventHandler = registerAzureLogger();
-  const { getCredential } = await import("./getCredential-Y4HWJOQE.js");
+  const { getCredential } = await import("./getCredential-SDHKBJNP.js");
   const credential = await getCredential(
     { loginMethod, cachePath, tenantId },
     { ...context, azureLogger: azureLogEventHandler }