@oneuptime/common 14.0.0 → 14.0.1

package/Types/API/URL.ts

@@ -459,7 +459,26 @@ export default class URL extends DatabaseProperty {
     const path: string = pathSegments.join("/");
 
     if (path || fragment) {
-      route = new Route(path + fragment);
+      /*
+       * The route is held without the "/" that separates it from the
+       * authority ("api/v1/items"), and toString puts it back. Dropping it is
+       * only harmless while the first segment has no ":" — once it does, the
+       * bare path reads as a scheme ("bot123:ABC/sendMessage" is scheme
+       * "bot123", RFC 3986 4.2) and Route rejects it. Telegram puts the bot
+       * token, which always contains a ":", in exactly that segment, so every
+       * https://api.telegram.org/bot<token>/... URL failed to parse — which
+       * broke the Telegram workflow component, the API components, and the
+       * SSRF check on every sandboxed axios call to Telegram.
+       *
+       * Keep the "/" for those paths only. It is the path as written, it
+       * cannot be read as a scheme, and toString produces the same string
+       * either way; every path that parsed before parses to the same Route.
+       */
+      const routeValue: string = path + fragment;
+
+      route = new Route(
+        Route.hasSchemePrefix(routeValue) ? "/" + routeValue : routeValue,
+      );
     }
 
     const queryString: string = URL.queryStringOf(url);
@@ -535,8 +554,13 @@ export default class URL extends DatabaseProperty {
   }
 
   public addRoute(route: Route | string): URL {
+    /*
+     * A string goes to Route.addRoute as-is, which prefixes the "/" before
+     * validating. Wrapping it in a Route first validated the bare form, so
+     * addRoute("bot123:ABC/sendMessage") threw for the same reason as above.
+     */
     if (typeof route === Typeof.String) {
-      this.route.addRoute(new Route(route.toString()));
+      this.route.addRoute(route.toString());
     }
 
     if (route instanceof Route) {

package/Types/Monitor/MetricMonitor/MetricCriteriaContext.ts

@@ -25,7 +25,8 @@ export interface MetricBreachingSample {
 
 /**
  * Descriptor for one variable referenced by a formula, used to label
- * table columns and render the Metric Details section. Name is the
+ * each breaching sample's component values and render the Metric
+ * Details section. Name is the
  * metric display name (usually the metric name, sometimes the formula
  * expression for nested formulas) and unit is the variable's native
  * unit as configured.
@@ -103,8 +104,8 @@ export default interface MetricCriteriaContext {
   breachingSample?: MetricBreachingSample | undefined;
   /**
    * All samples in the evaluation window that breached the threshold,
-   * in chronological order. Used to render a table of timestamps and
-   * values on the incident root-cause page.
+   * in chronological order. Used to render the Breaching Samples list
+   * of timestamps and values on the incident root-cause page.
    */
   breachingSamples?: Array<MetricBreachingSample> | undefined;
   /**
@@ -116,8 +117,8 @@ export default interface MetricCriteriaContext {
   /**
    * For formulas: metadata for each variable the formula references,
    * in the order they appear in the expression. Consumers use this to
-   * label breakdown columns and to surface underlying units/metric
-   * names in the Metric Details section.
+   * label each breaching sample's component values and to surface
+   * underlying units/metric names in the Metric Details section.
    */
   components?: Array<MetricComponent> | undefined;
 }

package/Types/Monitor/MetricMonitor/MetricMonitorResponse.ts

@@ -13,7 +13,16 @@ export interface KubernetesAffectedResource {
   containerName?: string | undefined;
   workloadType?: string | undefined;
   workloadName?: string | undefined;
+  /** Highest sample seen for this resource in the monitoring window. */
   metricValue: number;
+  /**
+   * Lowest sample seen for this resource in the monitoring window. A
+   * criteria that fires when the metric FALLS (node Ready = 0, etcd has
+   * leader = 0) breached on this value, not on `metricValue`: a node that
+   * was NotReady for one scrape and Ready for the rest has a highest of 1.
+   * Absent on breakdowns built before this field existed.
+   */
+  lowestMetricValue?: number | undefined;
 }
 
 export interface KubernetesResourceBreakdown {

package/Types/Permission.ts

@@ -2018,6 +2018,18 @@ enum Permission {
   EditServiceLevelObjectiveOwnerTeam = "EditServiceLevelObjectiveOwnerTeam",
   ReadServiceLevelObjectiveOwnerTeam = "ReadServiceLevelObjectiveOwnerTeam",
 
+  // Service Level Objective Owner Rule Permissions
+  CreateServiceLevelObjectiveOwnerRule = "CreateServiceLevelObjectiveOwnerRule",
+  DeleteServiceLevelObjectiveOwnerRule = "DeleteServiceLevelObjectiveOwnerRule",
+  EditServiceLevelObjectiveOwnerRule = "EditServiceLevelObjectiveOwnerRule",
+  ReadServiceLevelObjectiveOwnerRule = "ReadServiceLevelObjectiveOwnerRule",
+
+  // Service Level Objective Label Rule Permissions
+  CreateServiceLevelObjectiveLabelRule = "CreateServiceLevelObjectiveLabelRule",
+  DeleteServiceLevelObjectiveLabelRule = "DeleteServiceLevelObjectiveLabelRule",
+  EditServiceLevelObjectiveLabelRule = "EditServiceLevelObjectiveLabelRule",
+  ReadServiceLevelObjectiveLabelRule = "ReadServiceLevelObjectiveLabelRule",
+
   /*
    * Wildcard permissions covering all models marked @OperationalResource().
    * These short-circuit table-level checks for that resource class. Scope on
@@ -16140,6 +16152,84 @@ export class PermissionHelper {
         group: PermissionGroup.SLO,
       },
 
+      // Service Level Objective Owner Rule Permissions
+      {
+        permission: Permission.CreateServiceLevelObjectiveOwnerRule,
+        title: "Create SLO Owner Rule",
+        description:
+          "Permission to create SLO Owner Rules, which add owner users and teams to matching SLOs, in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+      {
+        permission: Permission.DeleteServiceLevelObjectiveOwnerRule,
+        title: "Delete SLO Owner Rule",
+        description: "Permission to delete SLO Owner Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+      {
+        permission: Permission.EditServiceLevelObjectiveOwnerRule,
+        title: "Edit SLO Owner Rule",
+        description: "Permission to edit SLO Owner Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+      {
+        permission: Permission.ReadServiceLevelObjectiveOwnerRule,
+        title: "Read SLO Owner Rule",
+        description: "Permission to read SLO Owner Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+
+      // Service Level Objective Label Rule Permissions
+      {
+        permission: Permission.CreateServiceLevelObjectiveLabelRule,
+        title: "Create SLO Label Rule",
+        description:
+          "Permission to create SLO Label Rules, which attach labels to matching SLOs, in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+      {
+        permission: Permission.DeleteServiceLevelObjectiveLabelRule,
+        title: "Delete SLO Label Rule",
+        description: "Permission to delete SLO Label Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+      {
+        permission: Permission.EditServiceLevelObjectiveLabelRule,
+        title: "Edit SLO Label Rule",
+        description: "Permission to edit SLO Label Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+      {
+        permission: Permission.ReadServiceLevelObjectiveLabelRule,
+        title: "Read SLO Label Rule",
+        description: "Permission to read SLO Label Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.SLO,
+      },
+
       // Operational Resource Wildcard Permissions
       {
         permission: Permission.ReadAllOperationalResources,

package/Types/Rules/RuleCriteriaFieldRegistry.ts

@@ -379,11 +379,22 @@ export const RULE_CRITERIA_FIELDS_BY_MODEL: Readonly<
     "serviceNamePattern",
     "serviceDescriptionPattern",
   ],
+  ServiceLevelObjectiveLabelRule: [
+    "serviceLevelObjectiveLabels",
+    "serviceLevelObjectiveNamePattern",
+    "serviceLevelObjectiveDescriptionPattern",
+  ],
   ServiceLevelObjectiveMonitorRule: [
     "monitorLabels",
+    "monitorType",
     "monitorNamePattern",
     "monitorDescriptionPattern",
   ],
+  ServiceLevelObjectiveOwnerRule: [
+    "serviceLevelObjectiveLabels",
+    "serviceLevelObjectiveNamePattern",
+    "serviceLevelObjectiveDescriptionPattern",
+  ],
   ServiceOwnerRule: [
     "serviceLabels",
     "serviceNamePattern",

package/Types/Rules/RuleRun.ts

@@ -92,7 +92,9 @@ export enum RuleRunType {
   ServerlessFunctionLabelRule = "ServerlessFunctionLabelRule",
   ServerlessFunctionOwnerRule = "ServerlessFunctionOwnerRule",
   ServiceLabelRule = "ServiceLabelRule",
+  ServiceLevelObjectiveLabelRule = "ServiceLevelObjectiveLabelRule",
   ServiceLevelObjectiveMonitorRule = "ServiceLevelObjectiveMonitorRule",
+  ServiceLevelObjectiveOwnerRule = "ServiceLevelObjectiveOwnerRule",
   ServiceOwnerRule = "ServiceOwnerRule",
   StatusPageLabelRule = "StatusPageLabelRule",
   StatusPageOwnerRule = "StatusPageOwnerRule",
@@ -316,11 +318,13 @@ export const RULE_RUN_TYPE_METADATA: Readonly<
     "serverless functions",
   ),
   [RuleRunType.ServiceLabelRule]: metadata(Labels, "service", "services"),
+  [RuleRunType.ServiceLevelObjectiveLabelRule]: metadata(Labels, "SLO", "SLOs"),
   [RuleRunType.ServiceLevelObjectiveMonitorRule]: metadata(
     RuleRunAction.SyncSloMonitors,
     "monitor",
     "monitors",
   ),
+  [RuleRunType.ServiceLevelObjectiveOwnerRule]: metadata(Owners, "SLO", "SLOs"),
   [RuleRunType.ServiceOwnerRule]: metadata(Owners, "service", "services"),
   [RuleRunType.StatusPageLabelRule]: metadata(
     Labels,

package/UI/Components/Feed/FeedOptions.ts

@@ -0,0 +1,427 @@
+import GenericObject from "../../../Types/GenericObject";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import IconProp from "../../../Types/Icon/IconProp";
+
+/*
+ * What a reader can change about a dashboard activity feed from its one
+ * "Filter & Sort" button: which way the timeline runs, and which kinds of
+ * event it shows.
+ *
+ * Both are applied by the API, never to the rows already in the browser. A
+ * feed is read a window at a time (see useFeedItems), so filtering the loaded
+ * window would show "no items" while matching events sat one page further
+ * back, and reversing it would show the newest ten upside down instead of the
+ * oldest ten.
+ *
+ * This module is React-free so the rules can be tested on their own.
+ */
+export interface FeedOptions {
+  sortOrder: SortOrder;
+  /*
+   * The event types to show. Empty means no filter, so every event type is
+   * shown - including one a feed model gains after the reader last looked.
+   */
+  eventTypes: Array<string>;
+}
+
+export const DEFAULT_FEED_SORT_ORDER: SortOrder = SortOrder.Descending;
+
+export const DEFAULT_FEED_OPTIONS: FeedOptions = {
+  sortOrder: DEFAULT_FEED_SORT_ORDER,
+  eventTypes: [],
+};
+
+export interface FeedSortOrderOption {
+  value: SortOrder;
+  label: string;
+  icon: IconProp;
+}
+
+export const FEED_SORT_ORDER_OPTIONS: Array<FeedSortOrderOption> = [
+  {
+    value: SortOrder.Descending,
+    label: "Newest first",
+    icon: IconProp.BarsArrowDown,
+  },
+  {
+    value: SortOrder.Ascending,
+    label: "Oldest first",
+    icon: IconProp.BarsArrowUp,
+  },
+];
+
+export interface FeedEventTypeOption {
+  value: string;
+  label: string;
+  icon?: IconProp | undefined;
+}
+
+export type GetFeedEventTypeLabelFunction = (
+  eventType: string,
+) => string | undefined;
+
+export type GetFeedEventTypeIconFunction = (
+  eventType: string,
+) => IconProp | undefined;
+
+/*
+ * Event types shared by many feeds whose split name reads badly
+ * ("Owner User Added"). A Map rather than an object literal, so an event type
+ * that happens to share a name with an Object.prototype member ("toString")
+ * cannot come back as a function.
+ */
+const EVENT_TYPE_LABELS: Map<string, string> = new Map<string, string>([
+  ["OwnerUserAdded", "User Added as Owner"],
+  ["OwnerUserRemoved", "User Removed as Owner"],
+  ["OwnerTeamAdded", "Team Added as Owner"],
+  ["OwnerTeamRemoved", "Team Removed as Owner"],
+  ["AutoRemediation", "Auto-Remediation"],
+]);
+
+/*
+ * Runs that camel-case splitting would get wrong, matched before any other
+ * word: "VMware" would split into "V Mware", "OnCall" should read
+ * "On-Call", and the SLO feed's "ServiceLevelObjective" prefix is written
+ * "SLO" everywhere else in the dashboard.
+ */
+const EVENT_TYPE_WORDS: Array<{ word: string; label: string }> = [
+  { word: "ServiceLevelObjective", label: "SLO" },
+  { word: "VMware", label: "VMware" },
+  { word: "VCenter", label: "vCenter" },
+  { word: "OnCall", label: "On-Call" },
+];
+
+// Joining words stay lower case inside a title ("Added to Episode").
+const LOWER_CASE_WORDS: Set<string> = new Set<string>([
+  "a",
+  "an",
+  "and",
+  "as",
+  "by",
+  "for",
+  "from",
+  "in",
+  "of",
+  "on",
+  "or",
+  "the",
+  "to",
+]);
+
+const EVENT_TYPE_WORD_PATTERN: RegExp = new RegExp(
+  `${EVENT_TYPE_WORDS.map((entry: { word: string }) => {
+    return entry.word;
+  }).join("|")}|[A-Z]+(?![a-z])|[A-Z]?[a-z]+|[0-9]+`,
+  "g",
+);
+
+type GetFeedEventTypeLabel = (eventType: string) => string;
+
+/*
+ * Feed event types are enum values named like "IncidentStateChanged", so a
+ * readable label is the value split into words. A feed with a better name for
+ * one of its own events passes getEventTypeLabel to getFeedEventTypeOptions.
+ */
+export const getFeedEventTypeLabel: GetFeedEventTypeLabel = (
+  eventType: string,
+): string => {
+  const knownLabel: string | undefined = EVENT_TYPE_LABELS.get(eventType);
+
+  if (knownLabel) {
+    return knownLabel;
+  }
+
+  const words: Array<string> = eventType.match(EVENT_TYPE_WORD_PATTERN) || [];
+
+  if (words.length === 0) {
+    return eventType;
+  }
+
+  return words
+    .map((word: string, index: number): string => {
+      const knownWord: { word: string; label: string } | undefined =
+        EVENT_TYPE_WORDS.find((entry: { word: string }) => {
+          return entry.word === word;
+        });
+
+      if (knownWord) {
+        return knownWord.label;
+      }
+
+      if (index > 0 && LOWER_CASE_WORDS.has(word.toLowerCase())) {
+        return word.toLowerCase();
+      }
+
+      return word.charAt(0).toUpperCase() + word.slice(1);
+    })
+    .join(" ");
+};
+
+type GetFeedEventTypeOptions = (data: {
+  eventTypes: Array<string>;
+  getEventTypeLabel?: GetFeedEventTypeLabelFunction | undefined;
+  getEventTypeIcon?: GetFeedEventTypeIconFunction | undefined;
+}) => Array<FeedEventTypeOption>;
+
+/*
+ * The checklist behind the button: one entry per event type, alphabetical by
+ * label so the reader can scan for the one they want.
+ */
+export const getFeedEventTypeOptions: GetFeedEventTypeOptions = (data: {
+  eventTypes: Array<string>;
+  getEventTypeLabel?: GetFeedEventTypeLabelFunction | undefined;
+  getEventTypeIcon?: GetFeedEventTypeIconFunction | undefined;
+}): Array<FeedEventTypeOption> => {
+  const uniqueEventTypes: Array<string> = Array.from(
+    new Set<string>(
+      data.eventTypes.filter((eventType: string) => {
+        return Boolean(eventType);
+      }),
+    ),
+  );
+
+  return uniqueEventTypes
+    .map((eventType: string): FeedEventTypeOption => {
+      return {
+        value: eventType,
+        label:
+          data.getEventTypeLabel?.(eventType) ||
+          getFeedEventTypeLabel(eventType),
+        icon: data.getEventTypeIcon?.(eventType),
+      };
+    })
+    .sort((a: FeedEventTypeOption, b: FeedEventTypeOption): number => {
+      return a.label.localeCompare(b.label);
+    });
+};
+
+type SanitizeFeedEventTypes = (data: {
+  selectedEventTypes: Array<string>;
+  knownEventTypes: Array<string>;
+}) => Array<string>;
+
+/*
+ * Keep only event types the feed actually has, once each, in the feed's own
+ * order. The order matters: it makes the request - and so the reload key -
+ * the same whichever order the reader ticked the boxes in.
+ */
+export const sanitizeFeedEventTypes: SanitizeFeedEventTypes = (data: {
+  selectedEventTypes: Array<string>;
+  knownEventTypes: Array<string>;
+}): Array<string> => {
+  const selected: Set<string> = new Set<string>(data.selectedEventTypes);
+
+  return Array.from(new Set<string>(data.knownEventTypes)).filter(
+    (eventType: string) => {
+      return selected.has(eventType);
+    },
+  );
+};
+
+type IsFeedSortOrder = (value: unknown) => value is SortOrder;
+
+export const isFeedSortOrder: IsFeedSortOrder = (
+  value: unknown,
+): value is SortOrder => {
+  return value === SortOrder.Ascending || value === SortOrder.Descending;
+};
+
+type GetFeedOptionsKey = (options: FeedOptions) => string;
+
+/*
+ * A stable string for "what this feed is showing". useFeedItems re-reads the
+ * feed from its first window whenever it changes.
+ */
+export const getFeedOptionsKey: GetFeedOptionsKey = (
+  options: FeedOptions,
+): string => {
+  return `${options.sortOrder}|${options.eventTypes.join(",")}`;
+};
+
+type IsFeedFiltered = (options: FeedOptions) => boolean;
+
+export const isFeedFiltered: IsFeedFiltered = (
+  options: FeedOptions,
+): boolean => {
+  return options.eventTypes.length > 0;
+};
+
+type IsDefaultFeedOptions = (options: FeedOptions) => boolean;
+
+export const isDefaultFeedOptions: IsDefaultFeedOptions = (
+  options: FeedOptions,
+): boolean => {
+  return (
+    options.sortOrder === DEFAULT_FEED_SORT_ORDER && !isFeedFiltered(options)
+  );
+};
+
+/*
+ * The query fragment for the event type filter, keyed by the feed model's
+ * event type column. It is empty when nothing is filtered, so an unfiltered
+ * feed sends exactly the query it always sent.
+ */
+export const getFeedEventTypeQuery: <TFeedModel extends GenericObject>(
+  eventTypeColumn: Extract<keyof TFeedModel, string>,
+  options: FeedOptions,
+) => Query<TFeedModel> = <TFeedModel extends GenericObject>(
+  eventTypeColumn: Extract<keyof TFeedModel, string>,
+  options: FeedOptions,
+): Query<TFeedModel> => {
+  if (!isFeedFiltered(options)) {
+    return {};
+  }
+
+  return {
+    [eventTypeColumn]: new Includes([...options.eventTypes]),
+  } as unknown as Query<TFeedModel>;
+};
+
+export const FILTERED_FEED_NO_ITEMS_MESSAGE: string =
+  "No events in this feed match the selected event types.";
+
+type GetFeedNoItemsMessage = (data: {
+  options: FeedOptions;
+  noItemsMessage: string;
+}) => string;
+
+/*
+ * An empty filtered feed says so, rather than claiming the resource has no
+ * activity at all.
+ */
+export const getFeedNoItemsMessage: GetFeedNoItemsMessage = (data: {
+  options: FeedOptions;
+  noItemsMessage: string;
+}): string => {
+  return isFeedFiltered(data.options)
+    ? FILTERED_FEED_NO_ITEMS_MESSAGE
+    : data.noItemsMessage;
+};
+
+/*
+ * The control's own sentences, as the English keys the dashboard's locale
+ * files translate (see Utils/Translation). The ones with placeholders are
+ * looked up whole and filled afterwards, so a translation can reorder the
+ * words around the numbers.
+ */
+export const FEED_OPTIONS_TEXT: {
+  triggerLabel: string;
+  searchResults: string;
+  panelLabel: string;
+  sortHeading: string;
+  eventTypesHeading: string;
+  showAll: string;
+  searchPlaceholder: string;
+  showingEveryEventType: string;
+  showingSomeEventTypes: string;
+  noSearchMatches: string;
+  noEventTypes: string;
+  reset: string;
+  summaryAllEventTypes: string;
+  summarySomeEventTypes: string;
+  summarySomeOfOneEventType: string;
+} = {
+  triggerLabel: "Filter & Sort",
+  searchResults: "Matching event types: {{count}}",
+  panelLabel: "Filter and sort feed",
+  sortHeading: "Sort by time",
+  eventTypesHeading: "Event types",
+  showAll: "Show all",
+  searchPlaceholder: "Search event types",
+  showingEveryEventType:
+    "Showing every event type. Tick one or more to narrow the feed.",
+  showingSomeEventTypes: "Showing {{selected}} of {{total}} event types.",
+  noSearchMatches: 'No event types match "{{search}}".',
+  noEventTypes: "This feed has no event types to filter by.",
+  reset: "Reset to default",
+  summaryAllEventTypes: "{{sortOrder}}, all event types",
+  summarySomeEventTypes: "{{sortOrder}}, {{selected}} of {{total}} event types",
+  summarySomeOfOneEventType:
+    "{{sortOrder}}, {{selected}} of {{total}} event type",
+};
+
+// Looks a sentence up in the reader's language; undefined means "as written".
+export type FeedOptionsTranslateFunction = (
+  text: string | undefined,
+) => string | undefined;
+
+const PLACEHOLDER_PATTERN: RegExp = /\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g;
+
+type TranslateFeedOptionsText = (data: {
+  text: string;
+  values?: Record<string, string | number> | undefined;
+  translate?: FeedOptionsTranslateFunction | undefined;
+}) => string;
+
+/*
+ * Translate, then fill the placeholders. A placeholder with no value is left
+ * showing, so a broken translation is visible rather than a sentence with a
+ * hole in it.
+ */
+export const translateFeedOptionsText: TranslateFeedOptionsText = (data: {
+  text: string;
+  values?: Record<string, string | number> | undefined;
+  translate?: FeedOptionsTranslateFunction | undefined;
+}): string => {
+  const translated: string =
+    (data.translate ? data.translate(data.text) : undefined) || data.text;
+  const values: Record<string, string | number> = data.values || {};
+
+  return translated.replace(
+    PLACEHOLDER_PATTERN,
+    (placeholder: string, name: string): string => {
+      const value: string | number | undefined = values[name];
+
+      return value === undefined ? placeholder : String(value);
+    },
+  );
+};
+
+type GetFeedOptionsSummary = (data: {
+  options: FeedOptions;
+  eventTypeCount: number;
+  translate?: FeedOptionsTranslateFunction | undefined;
+}) => string;
+
+/*
+ * One sentence for the trigger's accessible name and tooltip, so the state
+ * hidden behind the button can be read without opening it.
+ */
+export const getFeedOptionsSummary: GetFeedOptionsSummary = (data: {
+  options: FeedOptions;
+  eventTypeCount: number;
+  translate?: FeedOptionsTranslateFunction | undefined;
+}): string => {
+  const sortOrder: string = translateFeedOptionsText({
+    text:
+      FEED_SORT_ORDER_OPTIONS.find((option: FeedSortOrderOption) => {
+        return option.value === data.options.sortOrder;
+      })?.label || "Newest first",
+    translate: data.translate,
+  });
+
+  const selectedCount: number = data.options.eventTypes.length;
+
+  if (selectedCount === 0) {
+    return translateFeedOptionsText({
+      text: FEED_OPTIONS_TEXT.summaryAllEventTypes,
+      values: { sortOrder },
+      translate: data.translate,
+    });
+  }
+
+  return translateFeedOptionsText({
+    text:
+      data.eventTypeCount === 1
+        ? FEED_OPTIONS_TEXT.summarySomeOfOneEventType
+        : FEED_OPTIONS_TEXT.summarySomeEventTypes,
+    values: {
+      sortOrder,
+      selected: selectedCount,
+      total: data.eventTypeCount,
+    },
+    translate: data.translate,
+  });
+};