@depup/vercel 50.32.5-depup.0

package/dist/chunks/chunk-3FRG2XGZ.js

@@ -0,0 +1,466 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  TelemetryClient
+} from "./chunk-P4I4DMEU.js";
+
+// src/util/telemetry/commands/routes/index.ts
+var RoutesTelemetryClient = class extends TelemetryClient {
+  trackCliSubcommandList(actual) {
+    this.trackCliSubcommand({
+      subcommand: "list",
+      value: actual
+    });
+  }
+  trackCliSubcommandListVersions(actual) {
+    this.trackCliSubcommand({
+      subcommand: "list-versions",
+      value: actual
+    });
+  }
+  trackCliSubcommandInspect(actual) {
+    this.trackCliSubcommand({
+      subcommand: "inspect",
+      value: actual
+    });
+  }
+  trackCliSubcommandAdd(actual) {
+    this.trackCliSubcommand({
+      subcommand: "add",
+      value: actual
+    });
+  }
+  trackCliSubcommandPublish(actual) {
+    this.trackCliSubcommand({
+      subcommand: "publish",
+      value: actual
+    });
+  }
+  trackCliSubcommandRestore(actual) {
+    this.trackCliSubcommand({
+      subcommand: "restore",
+      value: actual
+    });
+  }
+  trackCliSubcommandDiscardStaging(actual) {
+    this.trackCliSubcommand({
+      subcommand: "discard-staging",
+      value: actual
+    });
+  }
+  trackCliSubcommandDelete(actual) {
+    this.trackCliSubcommand({
+      subcommand: "delete",
+      value: actual
+    });
+  }
+  trackCliSubcommandExport(actual) {
+    this.trackCliSubcommand({
+      subcommand: "export",
+      value: actual
+    });
+  }
+  trackCliSubcommandEnable(actual) {
+    this.trackCliSubcommand({
+      subcommand: "enable",
+      value: actual
+    });
+  }
+  trackCliSubcommandDisable(actual) {
+    this.trackCliSubcommand({
+      subcommand: "disable",
+      value: actual
+    });
+  }
+  trackCliSubcommandReorder(actual) {
+    this.trackCliSubcommand({
+      subcommand: "reorder",
+      value: actual
+    });
+  }
+  trackCliSubcommandEdit(actual) {
+    this.trackCliSubcommand({
+      subcommand: "edit",
+      value: actual
+    });
+  }
+};
+var RoutesAddTelemetryClient = class extends TelemetryClient {
+  // Argument tracking
+  trackCliArgumentName(name) {
+    if (name) {
+      this.trackCliArgument({
+        arg: "name",
+        value: this.redactedValue
+      });
+    }
+  }
+  // Flag tracking
+  trackCliFlagYes(flag) {
+    if (flag) {
+      this.trackCliFlag("yes");
+    }
+  }
+  trackCliFlagDisabled(flag) {
+    if (flag) {
+      this.trackCliFlag("disabled");
+    }
+  }
+  // Option tracking
+  trackCliOptionSrc(src) {
+    if (src) {
+      this.trackCliOption({
+        option: "src",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionSrcSyntax(syntax) {
+    if (syntax) {
+      this.trackCliOption({
+        option: "src-syntax",
+        value: syntax
+      });
+    }
+  }
+  trackCliOptionAction(action) {
+    if (action) {
+      this.trackCliOption({
+        option: "action",
+        value: action
+      });
+    }
+  }
+  trackCliOptionDest(dest) {
+    if (dest) {
+      this.trackCliOption({
+        option: "dest",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionStatus(status) {
+    if (status !== void 0) {
+      this.trackCliOption({
+        option: "status",
+        value: String(status)
+      });
+    }
+  }
+  trackCliOptionPosition(position) {
+    if (position) {
+      const placement = position.split(":")[0];
+      this.trackCliOption({
+        option: "position",
+        value: placement
+      });
+    }
+  }
+  trackCliOptionDescription(description) {
+    if (description) {
+      this.trackCliOption({
+        option: "description",
+        value: this.redactedValue
+      });
+    }
+  }
+  // Response header options
+  trackCliOptionSetResponseHeader(headers) {
+    if (headers && headers.length > 0) {
+      this.trackCliOption({
+        option: "set-response-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionAppendResponseHeader(headers) {
+    if (headers && headers.length > 0) {
+      this.trackCliOption({
+        option: "append-response-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionDeleteResponseHeader(headers) {
+    if (headers && headers.length > 0) {
+      this.trackCliOption({
+        option: "delete-response-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  // Request header options
+  trackCliOptionSetRequestHeader(headers) {
+    if (headers && headers.length > 0) {
+      this.trackCliOption({
+        option: "set-request-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionAppendRequestHeader(headers) {
+    if (headers && headers.length > 0) {
+      this.trackCliOption({
+        option: "append-request-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionDeleteRequestHeader(headers) {
+    if (headers && headers.length > 0) {
+      this.trackCliOption({
+        option: "delete-request-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  // Request query options
+  trackCliOptionSetRequestQuery(params) {
+    if (params && params.length > 0) {
+      this.trackCliOption({
+        option: "set-request-query",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionAppendRequestQuery(params) {
+    if (params && params.length > 0) {
+      this.trackCliOption({
+        option: "append-request-query",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionDeleteRequestQuery(params) {
+    if (params && params.length > 0) {
+      this.trackCliOption({
+        option: "delete-request-query",
+        value: this.redactedValue
+      });
+    }
+  }
+  // Condition options
+  trackCliOptionHas(conditions) {
+    if (conditions && conditions.length > 0) {
+      this.trackCliOption({
+        option: "has",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionMissing(conditions) {
+    if (conditions && conditions.length > 0) {
+      this.trackCliOption({
+        option: "missing",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionAi(prompt) {
+    if (prompt) {
+      this.trackCliOption({
+        option: "ai",
+        value: this.redactedValue
+      });
+    }
+  }
+  // Custom tracking methods (not part of interface, but useful)
+  trackCliActionType(actionType) {
+    this.trackCliOption({
+      option: "action-type",
+      value: actionType
+    });
+  }
+  trackCliFlagHasConditions(hasConditions) {
+    if (hasConditions) {
+      this.trackCliFlag("has-conditions");
+    }
+  }
+  trackCliFlagMissingConditions(hasMissingConditions) {
+    if (hasMissingConditions) {
+      this.trackCliFlag("missing-conditions");
+    }
+  }
+  trackCliFlagResponseHeaders(hasResponseHeaders) {
+    if (hasResponseHeaders) {
+      this.trackCliFlag("response-headers");
+    }
+  }
+  trackCliFlagRequestTransforms(hasRequestTransforms) {
+    if (hasRequestTransforms) {
+      this.trackCliFlag("request-transforms");
+    }
+  }
+};
+var RoutesEditTelemetryClient = class extends TelemetryClient {
+  trackCliArgumentNameOrId(id) {
+    if (id) {
+      this.trackCliArgument({ arg: "name-or-id", value: this.redactedValue });
+    }
+  }
+  trackCliFlagYes(flag) {
+    if (flag) {
+      this.trackCliFlag("yes");
+    }
+  }
+  trackCliFlagNoDest(flag) {
+    if (flag) {
+      this.trackCliFlag("no-dest");
+    }
+  }
+  trackCliFlagNoStatus(flag) {
+    if (flag) {
+      this.trackCliFlag("no-status");
+    }
+  }
+  trackCliFlagClearConditions(flag) {
+    if (flag) {
+      this.trackCliFlag("clear-conditions");
+    }
+  }
+  trackCliFlagClearHeaders(flag) {
+    if (flag) {
+      this.trackCliFlag("clear-headers");
+    }
+  }
+  trackCliFlagClearTransforms(flag) {
+    if (flag) {
+      this.trackCliFlag("clear-transforms");
+    }
+  }
+  trackCliOptionName(name) {
+    if (name) {
+      this.trackCliOption({ option: "name", value: this.redactedValue });
+    }
+  }
+  trackCliOptionDescription(desc) {
+    if (desc) {
+      this.trackCliOption({ option: "description", value: this.redactedValue });
+    }
+  }
+  trackCliOptionSrc(src) {
+    if (src) {
+      this.trackCliOption({ option: "src", value: this.redactedValue });
+    }
+  }
+  trackCliOptionSrcSyntax(syntax) {
+    if (syntax) {
+      this.trackCliOption({ option: "src-syntax", value: syntax });
+    }
+  }
+  trackCliOptionAction(action) {
+    if (action) {
+      this.trackCliOption({ option: "action", value: action });
+    }
+  }
+  trackCliOptionDest(dest) {
+    if (dest) {
+      this.trackCliOption({ option: "dest", value: this.redactedValue });
+    }
+  }
+  trackCliOptionStatus(status) {
+    if (status !== void 0) {
+      this.trackCliOption({ option: "status", value: String(status) });
+    }
+  }
+  trackCliOptionSetResponseHeader(h) {
+    if (h && h.length > 0) {
+      this.trackCliOption({
+        option: "set-response-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionAppendResponseHeader(h) {
+    if (h && h.length > 0) {
+      this.trackCliOption({
+        option: "append-response-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionDeleteResponseHeader(h) {
+    if (h && h.length > 0) {
+      this.trackCliOption({
+        option: "delete-response-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionSetRequestHeader(h) {
+    if (h && h.length > 0) {
+      this.trackCliOption({
+        option: "set-request-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionAppendRequestHeader(h) {
+    if (h && h.length > 0) {
+      this.trackCliOption({
+        option: "append-request-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionDeleteRequestHeader(h) {
+    if (h && h.length > 0) {
+      this.trackCliOption({
+        option: "delete-request-header",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionSetRequestQuery(p) {
+    if (p && p.length > 0) {
+      this.trackCliOption({
+        option: "set-request-query",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionAppendRequestQuery(p) {
+    if (p && p.length > 0) {
+      this.trackCliOption({
+        option: "append-request-query",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionDeleteRequestQuery(p) {
+    if (p && p.length > 0) {
+      this.trackCliOption({
+        option: "delete-request-query",
+        value: this.redactedValue
+      });
+    }
+  }
+  trackCliOptionHas(conditions) {
+    if (conditions && conditions.length > 0) {
+      this.trackCliOption({ option: "has", value: this.redactedValue });
+    }
+  }
+  trackCliOptionMissing(conditions) {
+    if (conditions && conditions.length > 0) {
+      this.trackCliOption({ option: "missing", value: this.redactedValue });
+    }
+  }
+  trackCliOptionAi(prompt) {
+    if (prompt) {
+      this.trackCliOption({
+        option: "ai",
+        value: this.redactedValue
+      });
+    }
+  }
+};
+
+export {
+  RoutesTelemetryClient,
+  RoutesAddTelemetryClient,
+  RoutesEditTelemetryClient
+};

package/dist/chunks/chunk-3KMKI2FP.js

@@ -0,0 +1,34 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  getTeamById,
+  getUser
+} from "./chunk-AQLVWVEN.js";
+import {
+  TeamDeleted
+} from "./chunk-ZLCMHY2G.js";
+
+// src/util/get-scope.ts
+async function getScope(client, opts = {}) {
+  const user = await getUser(client);
+  let contextName = user.username || user.email;
+  let team = null;
+  const defaultTeamId = user.version === "northstar" ? user.defaultTeamId : void 0;
+  const currentTeamOrDefaultTeamId = client.config.currentTeam || defaultTeamId;
+  if (currentTeamOrDefaultTeamId && opts.getTeam !== false) {
+    team = await getTeamById(client, currentTeamOrDefaultTeamId);
+    if (!team) {
+      throw new TeamDeleted();
+    }
+    contextName = team.slug;
+  }
+  return { contextName, team, user };
+}
+
+export {
+  getScope
+};

package/dist/chunks/chunk-3XFFP2BA.js

@@ -0,0 +1,110 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  __commonJS,
+  __esm,
+  __export,
+  __require,
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../internals/get-package-json/dist/index.js
+var require_dist = __commonJS({
+  "../../internals/get-package-json/dist/index.js"(exports, module) {
+    "use strict";
+    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 = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (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: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (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
+    ));
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export2(src_exports, {
+      getPackageJSON: () => getPackageJSON2
+    });
+    module.exports = __toCommonJS(src_exports);
+    var import_fs = __toESM2(__require("fs"));
+    var import_path = __toESM2(__require("path"));
+    var import_url = __require("url");
+    var cache = /* @__PURE__ */ new Map();
+    function getPackageJSONPath(dir) {
+      return import_path.default.join(dir, "package.json");
+    }
+    function captureCallerCallSite() {
+      const _prepareStackTrace = Error.prepareStackTrace;
+      let callSite;
+      try {
+        Error.prepareStackTrace = (_, stack) => stack;
+        const callSites = new Error().stack;
+        callSite = callSites[2];
+      } finally {
+        Error.prepareStackTrace = _prepareStackTrace;
+      }
+      return callSite;
+    }
+    function getPackageJSON2() {
+      const callSite = captureCallerCallSite();
+      let filePath = callSite.getFileName() || callSite.getEvalOrigin();
+      if (filePath.startsWith("file://")) {
+        filePath = (0, import_url.fileURLToPath)(filePath);
+      }
+      let rootDir = import_path.default.dirname(filePath);
+      let packageJSONPath = getPackageJSONPath(rootDir);
+      while (!import_fs.default.existsSync(packageJSONPath)) {
+        rootDir = import_path.default.join(rootDir, "..");
+        packageJSONPath = getPackageJSONPath(rootDir);
+      }
+      let packageJSON = cache.get(packageJSONPath);
+      if (!packageJSON) {
+        packageJSON = JSON.parse(import_fs.default.readFileSync(packageJSONPath, "utf-8"));
+        cache.set(packageJSONPath, packageJSON);
+      }
+      return packageJSON;
+    }
+  }
+});
+
+// src/util/pkg.ts
+var pkg_exports = {};
+__export(pkg_exports, {
+  default: () => pkg_default
+});
+var import_get_package_json, pkg_default;
+var init_pkg = __esm({
+  "src/util/pkg.ts"() {
+    "use strict";
+    import_get_package_json = __toESM(require_dist(), 1);
+    pkg_default = (0, import_get_package_json.getPackageJSON)();
+  }
+});
+
+export {
+  pkg_default,
+  pkg_exports,
+  init_pkg
+};