firebase-functions 6.5.0 → 7.0.0-rc.0

package/lib/esm/v1/providers/testLab.mjs

@@ -0,0 +1,94 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { makeCloudFunction } from "../cloud-functions.mjs";
+
+//#region src/v1/providers/testLab.ts
+var testLab_exports = /* @__PURE__ */ __export({
+	ClientInfo: () => ClientInfo,
+	PROVIDER: () => PROVIDER,
+	ResultStorage: () => ResultStorage,
+	SERVICE: () => SERVICE,
+	TEST_MATRIX_COMPLETE_EVENT_TYPE: () => TEST_MATRIX_COMPLETE_EVENT_TYPE,
+	TestMatrix: () => TestMatrix,
+	TestMatrixBuilder: () => TestMatrixBuilder,
+	_testMatrixWithOpts: () => _testMatrixWithOpts,
+	testMatrix: () => testMatrix
+});
+/** @internal */
+const PROVIDER = "google.testing";
+/** @internal */
+const SERVICE = "testing.googleapis.com";
+/** @internal */
+const TEST_MATRIX_COMPLETE_EVENT_TYPE = "testMatrix.complete";
+/** Handle events related to Test Lab test matrices. */
+function testMatrix() {
+	return _testMatrixWithOpts({});
+}
+/** @internal */
+function _testMatrixWithOpts(opts) {
+	return new TestMatrixBuilder(() => {
+		if (!process.env.GCLOUD_PROJECT) {
+			throw new Error("process.env.GCLOUD_PROJECT is not set.");
+		}
+		return "projects/" + process.env.GCLOUD_PROJECT + "/testMatrices/{matrix}";
+	}, opts);
+}
+/** Builder used to create Cloud Functions for Test Lab test matrices events. */
+var TestMatrixBuilder = class {
+	/** @internal */
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	/** Handle a TestMatrix that reached a final test state. */
+	onComplete(handler) {
+		const dataConstructor = (raw) => {
+			return new TestMatrix(raw.data);
+		};
+		return makeCloudFunction({
+			provider: PROVIDER,
+			eventType: TEST_MATRIX_COMPLETE_EVENT_TYPE,
+			triggerResource: this.triggerResource,
+			service: SERVICE,
+			dataConstructor,
+			handler,
+			options: this.options
+		});
+	}
+};
+/** TestMatrix captures details about a test run. */
+var TestMatrix = class {
+	/** @internal */
+	constructor(data) {
+		this.testMatrixId = data.testMatrixId;
+		this.createTime = data.timestamp;
+		this.state = data.state;
+		this.outcomeSummary = data.outcomeSummary;
+		this.invalidMatrixDetails = data.invalidMatrixDetails;
+		this.resultStorage = new ResultStorage(data.resultStorage);
+		this.clientInfo = new ClientInfo(data.clientInfo);
+	}
+};
+/** Information about the client which invoked the test. */
+var ClientInfo = class {
+	/** @internal */
+	constructor(data) {
+		this.name = data?.name || "";
+		this.details = {};
+		for (const detail of data?.clientInfoDetails || []) {
+			this.details[detail.key] = detail.value || "";
+		}
+	}
+};
+/** Locations where the test results are stored. */
+var ResultStorage = class {
+	/** @internal */
+	constructor(data) {
+		this.gcsPath = data?.googleCloudStorage?.gcsPath;
+		this.toolResultsHistoryId = data?.toolResultsHistory?.historyId;
+		this.toolResultsExecutionId = data?.toolResultsExecution?.executionId;
+		this.resultsUrl = data?.resultsUrl;
+	}
+};
+
+//#endregion
+export { ClientInfo, PROVIDER, ResultStorage, SERVICE, TEST_MATRIX_COMPLETE_EVENT_TYPE, TestMatrix, TestMatrixBuilder, _testMatrixWithOpts, testLab_exports, testMatrix };

package/lib/esm/v2/core.mjs

@@ -0,0 +1,4 @@
+import { Change } from "../common/change.mjs";
+import { onInit } from "../common/onInit.mjs";
+
+export { Change, onInit };

package/lib/esm/v2/index.mjs

@@ -0,0 +1,28 @@
+import { traceContext } from "../common/trace.mjs";
+import { logger_exports } from "../logger/index.mjs";
+import { params_exports } from "../params/index.mjs";
+import { setApp } from "../common/app.mjs";
+import { Change } from "../common/change.mjs";
+import { onInit } from "../common/onInit.mjs";
+import { config } from "../v1/config.mjs";
+import "./core.mjs";
+import { setGlobalOptions } from "./options.mjs";
+import { alerts_exports } from "./providers/alerts/index.mjs";
+import { database_exports } from "./providers/database.mjs";
+import { eventarc_exports } from "./providers/eventarc.mjs";
+import { https_exports } from "./providers/https.mjs";
+import { identity_exports } from "./providers/identity.mjs";
+import { pubsub_exports } from "./providers/pubsub.mjs";
+import { scheduler_exports } from "./providers/scheduler.mjs";
+import { storage_exports } from "./providers/storage.mjs";
+import { tasks_exports } from "./providers/tasks.mjs";
+import { remoteConfig_exports } from "./providers/remoteConfig.mjs";
+import { testLab_exports } from "./providers/testLab.mjs";
+import { firestore_exports } from "./providers/firestore.mjs";
+import { dataconnect_exports } from "./providers/dataconnect.mjs";
+
+//#region src/v2/index.ts
+const app = { setEmulatedAdminApp: setApp };
+
+//#endregion
+export { Change, alerts_exports as alerts, app, config, database_exports as database, dataconnect_exports as dataconnect, eventarc_exports as eventarc, firestore_exports as firestore, https_exports as https, identity_exports as identity, logger_exports as logger, onInit, params_exports as params, pubsub_exports as pubsub, remoteConfig_exports as remoteConfig, scheduler_exports as scheduler, setGlobalOptions, storage_exports as storage, tasks_exports as tasks, testLab_exports as testLab, traceContext };

package/lib/esm/v2/options.mjs

@@ -0,0 +1,102 @@
+import { warn } from "../logger/index.mjs";
+import { SecretParam } from "../params/types.mjs";
+import { declaredParams } from "../params/index.mjs";
+import { RESET_VALUE, ResetValue } from "../common/options.mjs";
+import { convertIfPresent, copyIfPresent, durationFromSeconds, serviceAccountFromShorthand } from "../common/encoding.mjs";
+
+//#region src/v2/options.ts
+const MemoryOptionToMB = {
+	"128MiB": 128,
+	"256MiB": 256,
+	"512MiB": 512,
+	"1GiB": 1024,
+	"2GiB": 2048,
+	"4GiB": 4096,
+	"8GiB": 8192,
+	"16GiB": 16384,
+	"32GiB": 32768
+};
+let globalOptions;
+/**
+* Sets default options for all functions written using the 2nd gen SDK.
+* @param options Options to set as default
+*/
+function setGlobalOptions(options) {
+	if (globalOptions) {
+		warn("Calling setGlobalOptions twice leads to undefined behavior");
+	}
+	globalOptions = options;
+}
+/**
+* Get the currently set default options.
+* Used only for trigger generation.
+* @internal
+*/
+function getGlobalOptions() {
+	return globalOptions || {};
+}
+/**
+* Apply GlobalOptions to trigger definitions.
+* @internal
+*/
+function optionsToTriggerAnnotations(opts) {
+	const annotation = {};
+	copyIfPresent(annotation, opts, "concurrency", "minInstances", "maxInstances", "ingressSettings", "labels", "vpcConnector", "vpcConnectorEgressSettings", "secrets");
+	convertIfPresent(annotation, opts, "availableMemoryMb", "memory", (mem) => {
+		return MemoryOptionToMB[mem];
+	});
+	convertIfPresent(annotation, opts, "regions", "region", (region) => {
+		if (typeof region === "string") {
+			return [region];
+		}
+		return region;
+	});
+	convertIfPresent(annotation, opts, "serviceAccountEmail", "serviceAccount", serviceAccountFromShorthand);
+	convertIfPresent(annotation, opts, "timeout", "timeoutSeconds", durationFromSeconds);
+	convertIfPresent(annotation, opts, "failurePolicy", "retry", (retry) => {
+		return retry ? { retry: true } : null;
+	});
+	return annotation;
+}
+/**
+* Apply GlobalOptions to endpoint manifest.
+* @internal
+*/
+function optionsToEndpoint(opts) {
+	const endpoint = {};
+	copyIfPresent(endpoint, opts, "omit", "concurrency", "minInstances", "maxInstances", "ingressSettings", "labels", "timeoutSeconds", "cpu");
+	convertIfPresent(endpoint, opts, "serviceAccountEmail", "serviceAccount");
+	if (opts.vpcConnector !== undefined) {
+		if (opts.vpcConnector === null || opts.vpcConnector instanceof ResetValue) {
+			endpoint.vpc = RESET_VALUE;
+		} else {
+			const vpc = { connector: opts.vpcConnector };
+			convertIfPresent(vpc, opts, "egressSettings", "vpcConnectorEgressSettings");
+			endpoint.vpc = vpc;
+		}
+	}
+	convertIfPresent(endpoint, opts, "availableMemoryMb", "memory", (mem) => {
+		return typeof mem === "object" ? mem : MemoryOptionToMB[mem];
+	});
+	convertIfPresent(endpoint, opts, "region", "region", (region) => {
+		if (typeof region === "string") {
+			return [region];
+		}
+		return region;
+	});
+	convertIfPresent(endpoint, opts, "secretEnvironmentVariables", "secrets", (secrets) => secrets.map((secret) => ({ key: secret instanceof SecretParam ? secret.name : secret })));
+	return endpoint;
+}
+/**
+* @hidden
+* @alpha
+*/
+function __getSpec() {
+	return {
+		globalOptions: getGlobalOptions(),
+		params: declaredParams.map((p) => p.toSpec())
+	};
+}
+
+//#endregion
+export { RESET_VALUE, __getSpec, getGlobalOptions, optionsToEndpoint, optionsToTriggerAnnotations, setGlobalOptions };

package/lib/esm/v2/providers/alerts/alerts.mjs

@@ -0,0 +1,85 @@
+import { initV2Endpoint } from "../../../runtime/manifest.mjs";
+import { withInit } from "../../../common/onInit.mjs";
+import { wrapTraceContext } from "../../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../../options.mjs";
+
+//#region src/v2/providers/alerts/alerts.ts
+/** @internal */
+const eventType = "google.firebase.firebasealerts.alerts.v1.published";
+function onAlertPublished(alertTypeOrOpts, handler) {
+	const [opts, alertType, appId] = getOptsAndAlertTypeAndApp(alertTypeOrOpts);
+	const func = (raw) => {
+		return wrapTraceContext(withInit(handler))(convertAlertAndApp(raw));
+	};
+	func.run = handler;
+	func.__endpoint = getEndpointAnnotation(opts, alertType, appId);
+	return func;
+}
+/**
+* Helper function for getting the endpoint annotation used in alert handling functions.
+* @internal
+*/
+function getEndpointAnnotation(opts, alertType, appId) {
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	const endpoint = {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType,
+			eventFilters: { alerttype: alertType },
+			retry: opts.retry ?? false
+		}
+	};
+	if (appId) {
+		endpoint.eventTrigger.eventFilters.appid = appId;
+	}
+	return endpoint;
+}
+/**
+* Helper function to parse the function opts, alert type, and appId.
+* @internal
+*/
+function getOptsAndAlertTypeAndApp(alertTypeOrOpts) {
+	let opts;
+	let alertType;
+	let appId;
+	if (typeof alertTypeOrOpts === "string") {
+		alertType = alertTypeOrOpts;
+		opts = {};
+	} else {
+		alertType = alertTypeOrOpts.alertType;
+		appId = alertTypeOrOpts.appId;
+		opts = { ...alertTypeOrOpts };
+		delete opts.alertType;
+		delete opts.appId;
+	}
+	return [
+		opts,
+		alertType,
+		appId
+	];
+}
+/**
+* Helper function to covert alert type & app id in the CloudEvent to camel case.
+* @internal
+*/
+function convertAlertAndApp(raw) {
+	const event = { ...raw };
+	if ("alerttype" in event) {
+		event.alertType = event.alerttype;
+	}
+	if ("appid" in event) {
+		event.appId = event.appid;
+	}
+	return event;
+}
+
+//#endregion
+export { convertAlertAndApp, eventType, getEndpointAnnotation, getOptsAndAlertTypeAndApp, onAlertPublished };

package/lib/esm/v2/providers/alerts/appDistribution.mjs

@@ -0,0 +1,75 @@
+import { __export } from "../../../_virtual/rolldown_runtime.mjs";
+import { withInit } from "../../../common/onInit.mjs";
+import { wrapTraceContext } from "../../trace.mjs";
+import { convertAlertAndApp, getEndpointAnnotation } from "./alerts.mjs";
+
+//#region src/v2/providers/alerts/appDistribution.ts
+var appDistribution_exports = /* @__PURE__ */ __export({
+	getOptsAndApp: () => getOptsAndApp,
+	inAppFeedbackAlert: () => inAppFeedbackAlert,
+	newTesterIosDeviceAlert: () => newTesterIosDeviceAlert,
+	onInAppFeedbackPublished: () => onInAppFeedbackPublished,
+	onNewTesterIosDevicePublished: () => onNewTesterIosDevicePublished
+});
+/** @internal */
+const newTesterIosDeviceAlert = "appDistribution.newTesterIosDevice";
+/** @internal */
+const inAppFeedbackAlert = "appDistribution.inAppFeedback";
+/**
+* Declares a function that can handle adding a new tester iOS device.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler which is run every time a new tester iOS device is added.
+* @returns A function that you can export and deploy.
+*/
+function onNewTesterIosDevicePublished(appIdOrOptsOrHandler, handler) {
+	if (typeof appIdOrOptsOrHandler === "function") {
+		handler = appIdOrOptsOrHandler;
+		appIdOrOptsOrHandler = {};
+	}
+	const [opts, appId] = getOptsAndApp(appIdOrOptsOrHandler);
+	const func = (raw) => {
+		return wrapTraceContext(withInit(handler))(convertAlertAndApp(raw));
+	};
+	func.run = handler;
+	func.__endpoint = getEndpointAnnotation(opts, newTesterIosDeviceAlert, appId);
+	return func;
+}
+/**
+* Declares a function that can handle receiving new in-app feedback from a tester.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler which is run every time new feedback is received.
+* @returns A function that you can export and deploy.
+*/
+function onInAppFeedbackPublished(appIdOrOptsOrHandler, handler) {
+	if (typeof appIdOrOptsOrHandler === "function") {
+		handler = appIdOrOptsOrHandler;
+		appIdOrOptsOrHandler = {};
+	}
+	const [opts, appId] = getOptsAndApp(appIdOrOptsOrHandler);
+	const func = (raw) => {
+		return wrapTraceContext(withInit(handler))(convertAlertAndApp(raw));
+	};
+	func.run = handler;
+	func.__endpoint = getEndpointAnnotation(opts, inAppFeedbackAlert, appId);
+	return func;
+}
+/**
+* Helper function to parse the function opts and appId.
+* @internal
+*/
+function getOptsAndApp(appIdOrOpts) {
+	let opts;
+	let appId;
+	if (typeof appIdOrOpts === "string") {
+		opts = {};
+		appId = appIdOrOpts;
+	} else {
+		appId = appIdOrOpts.appId;
+		opts = { ...appIdOrOpts };
+		delete opts.appId;
+	}
+	return [opts, appId];
+}
+
+//#endregion
+export { appDistribution_exports, getOptsAndApp, inAppFeedbackAlert, newTesterIosDeviceAlert, onInAppFeedbackPublished, onNewTesterIosDevicePublished };

package/lib/esm/v2/providers/alerts/billing.mjs

@@ -0,0 +1,51 @@
+import { __export } from "../../../_virtual/rolldown_runtime.mjs";
+import { withInit } from "../../../common/onInit.mjs";
+import { wrapTraceContext } from "../../trace.mjs";
+import { convertAlertAndApp, getEndpointAnnotation } from "./alerts.mjs";
+
+//#region src/v2/providers/alerts/billing.ts
+var billing_exports = /* @__PURE__ */ __export({
+	onOperation: () => onOperation,
+	onPlanAutomatedUpdatePublished: () => onPlanAutomatedUpdatePublished,
+	onPlanUpdatePublished: () => onPlanUpdatePublished,
+	planAutomatedUpdateAlert: () => planAutomatedUpdateAlert,
+	planUpdateAlert: () => planUpdateAlert
+});
+/** @internal */
+const planUpdateAlert = "billing.planUpdate";
+/** @internal */
+const planAutomatedUpdateAlert = "billing.planAutomatedUpdate";
+/**
+* Declares a function that can handle a billing plan update event.
+* @param optsOrHandler - Options or an event-handling function.
+* @param handler - Event handler which is run every time a billing plan is updated.
+* @returns A function that you can export and deploy.
+*/
+function onPlanUpdatePublished(optsOrHandler, handler) {
+	return onOperation(planUpdateAlert, optsOrHandler, handler);
+}
+/**
+* Declares a function that can handle an automated billing plan update event.
+* @param optsOrHandler - Options or an event-handling function.
+* @param handler - Event handler which is run every time an automated billing plan update occurs.
+* @returns A function that you can export and deploy.
+*/
+function onPlanAutomatedUpdatePublished(optsOrHandler, handler) {
+	return onOperation(planAutomatedUpdateAlert, optsOrHandler, handler);
+}
+/** @internal */
+function onOperation(alertType, optsOrHandler, handler) {
+	if (typeof optsOrHandler === "function") {
+		handler = optsOrHandler;
+		optsOrHandler = {};
+	}
+	const func = (raw) => {
+		return wrapTraceContext(withInit(handler))(convertAlertAndApp(raw));
+	};
+	func.run = handler;
+	func.__endpoint = getEndpointAnnotation(optsOrHandler, alertType);
+	return func;
+}
+
+//#endregion
+export { billing_exports, onOperation, onPlanAutomatedUpdatePublished, onPlanUpdatePublished, planAutomatedUpdateAlert, planUpdateAlert };

package/lib/esm/v2/providers/alerts/crashlytics.mjs

@@ -0,0 +1,122 @@
+import { __export } from "../../../_virtual/rolldown_runtime.mjs";
+import { withInit } from "../../../common/onInit.mjs";
+import { wrapTraceContext } from "../../trace.mjs";
+import { convertAlertAndApp, getEndpointAnnotation } from "./alerts.mjs";
+
+//#region src/v2/providers/alerts/crashlytics.ts
+var crashlytics_exports = /* @__PURE__ */ __export({
+	getOptsAndApp: () => getOptsAndApp,
+	newAnrIssueAlert: () => newAnrIssueAlert,
+	newFatalIssueAlert: () => newFatalIssueAlert,
+	newNonfatalIssueAlert: () => newNonfatalIssueAlert,
+	onNewAnrIssuePublished: () => onNewAnrIssuePublished,
+	onNewFatalIssuePublished: () => onNewFatalIssuePublished,
+	onNewNonfatalIssuePublished: () => onNewNonfatalIssuePublished,
+	onOperation: () => onOperation,
+	onRegressionAlertPublished: () => onRegressionAlertPublished,
+	onStabilityDigestPublished: () => onStabilityDigestPublished,
+	onVelocityAlertPublished: () => onVelocityAlertPublished,
+	regressionAlert: () => regressionAlert,
+	stabilityDigestAlert: () => stabilityDigestAlert,
+	velocityAlert: () => velocityAlert
+});
+/** @internal */
+const newFatalIssueAlert = "crashlytics.newFatalIssue";
+/** @internal */
+const newNonfatalIssueAlert = "crashlytics.newNonfatalIssue";
+/** @internal */
+const regressionAlert = "crashlytics.regression";
+/** @internal */
+const stabilityDigestAlert = "crashlytics.stabilityDigest";
+/** @internal */
+const velocityAlert = "crashlytics.velocity";
+/** @internal */
+const newAnrIssueAlert = "crashlytics.newAnrIssue";
+/**
+* Declares a function that can handle a new fatal issue published to Crashlytics.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler that is triggered when a new fatal issue is published to Crashlytics.
+* @returns A function that you can export and deploy.
+*/
+function onNewFatalIssuePublished(appIdOrOptsOrHandler, handler) {
+	return onOperation(newFatalIssueAlert, appIdOrOptsOrHandler, handler);
+}
+/**
+* Declares a function that can handle a new non-fatal issue published to Crashlytics.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler that is triggered when a new non-fatal issue is published to Crashlytics.
+* @returns A function that you can export and deploy.
+*/
+function onNewNonfatalIssuePublished(appIdOrOptsOrHandler, handler) {
+	return onOperation(newNonfatalIssueAlert, appIdOrOptsOrHandler, handler);
+}
+/**
+* Declares a function that can handle a regression alert published to Crashlytics.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler that is triggered when a regression alert is published to Crashlytics.
+* @returns A function that you can export and deploy.
+*/
+function onRegressionAlertPublished(appIdOrOptsOrHandler, handler) {
+	return onOperation(regressionAlert, appIdOrOptsOrHandler, handler);
+}
+/**
+* Declares a function that can handle a stability digest published to Crashlytics.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler that is triggered when a stability digest is published to Crashlytics.
+* @returns A function that you can export and deploy.
+*/
+function onStabilityDigestPublished(appIdOrOptsOrHandler, handler) {
+	return onOperation(stabilityDigestAlert, appIdOrOptsOrHandler, handler);
+}
+/**
+* Declares a function that can handle a velocity alert published to Crashlytics.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler that is triggered when a velocity alert is published to Crashlytics.
+* @returns A function that you can export and deploy.
+*/
+function onVelocityAlertPublished(appIdOrOptsOrHandler, handler) {
+	return onOperation(velocityAlert, appIdOrOptsOrHandler, handler);
+}
+/**
+* Declares a function that can handle a new Application Not Responding issue published to Crashlytics.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler that is triggered when a new Application Not Responding issue is published to Crashlytics.
+* @returns A function that you can export and deploy.
+*/
+function onNewAnrIssuePublished(appIdOrOptsOrHandler, handler) {
+	return onOperation(newAnrIssueAlert, appIdOrOptsOrHandler, handler);
+}
+/** @internal */
+function onOperation(alertType, appIdOrOptsOrHandler, handler) {
+	if (typeof appIdOrOptsOrHandler === "function") {
+		handler = appIdOrOptsOrHandler;
+		appIdOrOptsOrHandler = {};
+	}
+	const [opts, appId] = getOptsAndApp(appIdOrOptsOrHandler);
+	const func = (raw) => {
+		return wrapTraceContext(withInit(handler))(convertAlertAndApp(raw));
+	};
+	func.run = handler;
+	func.__endpoint = getEndpointAnnotation(opts, alertType, appId);
+	return func;
+}
+/**
+* Helper function to parse the function opts and appId.
+* @internal
+*/
+function getOptsAndApp(appIdOrOpts) {
+	let opts;
+	let appId;
+	if (typeof appIdOrOpts === "string") {
+		opts = {};
+		appId = appIdOrOpts;
+	} else {
+		appId = appIdOrOpts.appId;
+		opts = { ...appIdOrOpts };
+		delete opts.appId;
+	}
+	return [opts, appId];
+}
+
+//#endregion
+export { crashlytics_exports, getOptsAndApp, newAnrIssueAlert, newFatalIssueAlert, newNonfatalIssueAlert, onNewAnrIssuePublished, onNewFatalIssuePublished, onNewNonfatalIssuePublished, onOperation, onRegressionAlertPublished, onStabilityDigestPublished, onVelocityAlertPublished, regressionAlert, stabilityDigestAlert, velocityAlert };

package/lib/esm/v2/providers/alerts/index.mjs

@@ -0,0 +1,22 @@
+import { __export } from "../../../_virtual/rolldown_runtime.mjs";
+import { convertAlertAndApp, eventType, getEndpointAnnotation, getOptsAndAlertTypeAndApp, onAlertPublished } from "./alerts.mjs";
+import { appDistribution_exports } from "./appDistribution.mjs";
+import { billing_exports } from "./billing.mjs";
+import { crashlytics_exports } from "./crashlytics.mjs";
+import { performance_exports } from "./performance.mjs";
+
+//#region src/v2/providers/alerts/index.ts
+var alerts_exports = /* @__PURE__ */ __export({
+	appDistribution: () => appDistribution_exports,
+	billing: () => billing_exports,
+	convertAlertAndApp: () => convertAlertAndApp,
+	crashlytics: () => crashlytics_exports,
+	eventType: () => eventType,
+	getEndpointAnnotation: () => getEndpointAnnotation,
+	getOptsAndAlertTypeAndApp: () => getOptsAndAlertTypeAndApp,
+	onAlertPublished: () => onAlertPublished,
+	performance: () => performance_exports
+});
+
+//#endregion
+export { alerts_exports, appDistribution_exports as appDistribution, billing_exports as billing, convertAlertAndApp, crashlytics_exports as crashlytics, eventType, getEndpointAnnotation, getOptsAndAlertTypeAndApp, onAlertPublished, performance_exports as performance };

package/lib/esm/v2/providers/alerts/performance.mjs

@@ -0,0 +1,66 @@
+import { __export } from "../../../_virtual/rolldown_runtime.mjs";
+import { withInit } from "../../../common/onInit.mjs";
+import { wrapTraceContext } from "../../trace.mjs";
+import { convertAlertAndApp, getEndpointAnnotation } from "./alerts.mjs";
+
+//#region src/v2/providers/alerts/performance.ts
+var performance_exports = /* @__PURE__ */ __export({
+	convertPayload: () => convertPayload,
+	getOptsAndApp: () => getOptsAndApp,
+	onThresholdAlertPublished: () => onThresholdAlertPublished,
+	thresholdAlert: () => thresholdAlert
+});
+/** @internal */
+const thresholdAlert = "performance.threshold";
+/**
+* Declares a function that can handle receiving performance threshold alerts.
+* @param appIdOrOptsOrHandler - A specific application, options, or an event-handling function.
+* @param handler - Event handler which is run every time a threshold alert is received.
+* @returns A function that you can export and deploy.
+*/
+function onThresholdAlertPublished(appIdOrOptsOrHandler, handler) {
+	if (typeof appIdOrOptsOrHandler === "function") {
+		handler = appIdOrOptsOrHandler;
+		appIdOrOptsOrHandler = {};
+	}
+	const [opts, appId] = getOptsAndApp(appIdOrOptsOrHandler);
+	const func = (raw) => {
+		const event = convertAlertAndApp(raw);
+		const convertedPayload = convertPayload(event.data.payload);
+		event.data.payload = convertedPayload;
+		return wrapTraceContext(withInit(handler(event)));
+	};
+	func.run = handler;
+	func.__endpoint = getEndpointAnnotation(opts, thresholdAlert, appId);
+	return func;
+}
+/**
+* Helper function to parse the function opts and appId.
+* @internal
+*/
+function getOptsAndApp(appIdOrOpts) {
+	if (typeof appIdOrOpts === "string") {
+		return [{}, appIdOrOpts];
+	}
+	const opts = { ...appIdOrOpts };
+	const appId = appIdOrOpts.appId;
+	delete opts.appId;
+	return [opts, appId];
+}
+/**
+* Helper function to convert the raw payload of a {@link PerformanceEvent} to a {@link ThresholdAlertPayload}
+* @internal
+*/
+function convertPayload(raw) {
+	const payload = { ...raw };
+	if (typeof payload.conditionPercentile !== "undefined" && payload.conditionPercentile === 0) {
+		delete payload.conditionPercentile;
+	}
+	if (typeof payload.appVersion !== "undefined" && payload.appVersion.length === 0) {
+		delete payload.appVersion;
+	}
+	return payload;
+}
+
+//#endregion
+export { convertPayload, getOptsAndApp, onThresholdAlertPublished, performance_exports, thresholdAlert };