@northern.tech/store 0.2.0 → 0.3.0

package/dist/utils.cjs

@@ -0,0 +1,739 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  convertDeviceListStateToFilters: () => convertDeviceListStateToFilters,
+  filtersFilter: () => filtersFilter,
+  generateDeploymentGroupDetails: () => generateDeploymentGroupDetails,
+  getComparisonCompatibleVersion: () => getComparisonCompatibleVersion,
+  getDeploymentState: () => getDeploymentState,
+  groupDeploymentDevicesStats: () => groupDeploymentDevicesStats,
+  groupDeploymentStats: () => groupDeploymentStats,
+  isDarkMode: () => isDarkMode,
+  listItemMapper: () => listItemMapper,
+  mapDeviceAttributes: () => mapDeviceAttributes,
+  mapFiltersToTerms: () => mapFiltersToTerms,
+  mapTermsToFilters: () => mapTermsToFilters,
+  mapUserRolesToUiPermissions: () => mapUserRolesToUiPermissions,
+  mergePermissions: () => mergePermissions,
+  progress: () => progress,
+  statCollector: () => statCollector,
+  stringToBoolean: () => stringToBoolean
+});
+module.exports = __toCommonJS(utils_exports);
+var import_helpers = require("@northern.tech/utils/helpers");
+
+// src/commonConstants.tsx
+var import_js = require("@mdi/js");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DEVICE_LIST_DEFAULTS = {
+  page: 1,
+  perPage: 20
+};
+var timeUnits = {
+  days: "days",
+  minutes: "minutes",
+  hours: "hours"
+};
+var DEVICE_LIST_MAXIMUM_LENGTH = 50;
+var DEVICE_FILTERING_OPTIONS = {
+  $eq: { key: "$eq", title: "equals", shortform: "=" },
+  $ne: { key: "$ne", title: "not equal", shortform: "!=" },
+  $gt: {
+    key: "$gt",
+    title: ">",
+    shortform: ">",
+    help: 'The "greater than" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
+  },
+  $gte: {
+    title: ">=",
+    shortform: ">=",
+    help: 'The "greater than or equal" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
+  },
+  $lt: {
+    key: "$lt",
+    title: "<",
+    shortform: "<",
+    help: 'The "lesser than" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
+  },
+  $lte: {
+    title: "<=",
+    shortform: "<=",
+    help: 'The "lesser than or equal" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
+  },
+  $ltne: {
+    key: "$ltne",
+    title: "$ltne",
+    shortform: "ltne",
+    help: 'The "lesser than or does not exist" operator can work both on numbers and strings. In the latter case, the operator applies the lexicographical order to the value strings.'
+  },
+  $in: {
+    key: "$in",
+    title: "in",
+    shortform: "in",
+    help: 'The "in" operator accepts a list of comma-separated values. It matches if the selected field is equal to one of the specified values.'
+  },
+  $nin: {
+    key: "$nin",
+    title: "not in",
+    shortform: "not in",
+    help: `The "not in" operator accepts a list of comma-separated values. It matches if the selected field's value is not equal to any of the specified options.`
+  },
+  $exists: {
+    key: "$exists",
+    title: "exists",
+    shortform: "exists",
+    value: true,
+    help: `The "exists" operator matches if the selected field's value has a value. No value needs to be provided for this operator.`
+  },
+  $nexists: {
+    key: "$nexists",
+    title: `doesn't exist`,
+    shortform: `doesn't exist`,
+    value: true,
+    help: `The "doesn't exist" operator matches if the selected field's value has no value. No value needs to be provided for this operator.`
+  },
+  $regex: {
+    key: "$regex",
+    title: `matches regular expression`,
+    shortform: `matches`,
+    help: `The "regular expression" operator matches the selected field's value with a Perl compatible regular expression (PCRE), automatically anchored by ^. If the regular expression is not valid, the filter will produce no results. If you need to specify options and flags, you can provide the full regex in the format of /regex/flags, for example.`
+  }
+};
+var DEVICE_ISSUE_OPTIONS = {
+  issues: {
+    isCategory: true,
+    key: "issues",
+    title: "Devices with issues",
+    filterRule: {}
+  },
+  offline: {
+    issueCategory: "issues",
+    key: "offline",
+    needsFullFiltering: true,
+    needsMonitor: false,
+    needsReporting: false,
+    filterRule: {
+      scope: "system",
+      key: "check_in_time",
+      operator: DEVICE_FILTERING_OPTIONS.$ltne.key,
+      value: ({ offlineThreshold }) => offlineThreshold
+    },
+    title: "Offline devices"
+  },
+  failedLastUpdate: {
+    issueCategory: "issues",
+    key: "failedLastUpdate",
+    needsFullFiltering: false,
+    needsMonitor: false,
+    needsReporting: true,
+    filterRule: { scope: "monitor", key: "failed_last_update", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: true },
+    title: "Deployment failed"
+  },
+  monitoring: {
+    issueCategory: "issues",
+    key: "monitoring",
+    needsFullFiltering: false,
+    needsMonitor: true,
+    needsReporting: false,
+    filterRule: { scope: "monitor", key: "alerts", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: true },
+    title: "Monitoring alert"
+  },
+  authRequests: {
+    key: "authRequests",
+    needsFullFiltering: false,
+    needsMonitor: false,
+    needsReporting: true,
+    filterRule: { scope: "monitor", key: "auth_requests", operator: DEVICE_FILTERING_OPTIONS.$gt.key, value: 1 },
+    title: "Devices with new authentication requests"
+  },
+  gatewayDevices: {
+    key: "gatewayDevices",
+    needsFullFiltering: false,
+    needsMonitor: false,
+    needsReporting: true,
+    filterRule: { scope: "inventory", key: "mender_is_gateway", operator: DEVICE_FILTERING_OPTIONS.$eq.key, value: "true" },
+    title: "Gateway devices"
+  }
+};
+var oneSecond = 1e3;
+var TIMEOUTS = {
+  debounceDefault: 700,
+  debounceShort: 300,
+  halfASecond: 0.5 * oneSecond,
+  oneSecond,
+  twoSeconds: 2 * oneSecond,
+  threeSeconds: 3 * oneSecond,
+  fiveSeconds: 5 * oneSecond,
+  refreshDefault: 10 * oneSecond,
+  refreshLong: 60 * oneSecond
+};
+var SORTING_OPTIONS = {
+  asc: "asc",
+  desc: "desc"
+};
+var DEVICE_ONLINE_CUTOFF = { interval: 1, intervalName: timeUnits.days };
+var ATTRIBUTE_SCOPES = {
+  inventory: "inventory",
+  identity: "identity",
+  monitor: "monitor",
+  system: "system",
+  tags: "tags"
+};
+var defaultIdAttribute = Object.freeze({ attribute: "id", scope: ATTRIBUTE_SCOPES.identity });
+var credentialTypes = {
+  aws: "aws",
+  http: "http",
+  sas: "sas",
+  x509: "x509"
+};
+var EXTERNAL_PROVIDER = {
+  "iot-core": {
+    credentialsType: credentialTypes.aws,
+    icon: import_js.mdiAws,
+    title: "AWS IoT Core",
+    twinTitle: "Device Shadow",
+    provider: "iot-core",
+    enabled: true,
+    deviceTwin: true,
+    configHint: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: "For help finding your AWS IoT Core connection string, check the AWS IoT documentation." })
+  },
+  "iot-hub": {
+    credentialsType: credentialTypes.sas,
+    icon: import_js.mdiMicrosoftAzure,
+    title: "Azure IoT Hub",
+    twinTitle: "Device Twin",
+    provider: "iot-hub",
+    enabled: true,
+    deviceTwin: true,
+    configHint: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+      "For help finding your Azure IoT Hub connection string, look under 'Shared access policies' in the Microsoft Azure UI as described",
+      " ",
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "a",
+        {
+          href: "https://devblogs.microsoft.com/iotdev/understand-different-connection-strings-in-azure-iot-hub/#iothubconn",
+          target: "_blank",
+          rel: "noopener noreferrer",
+          children: "here"
+        }
+      ),
+      "."
+    ] })
+  },
+  webhook: {
+    credentialsType: credentialTypes.http,
+    deviceTwin: false,
+    // disable the webhook provider here, since it is treated different than other integrations, with a custom configuration & management view, etc.
+    enabled: false,
+    provider: "webhook"
+  }
+};
+var emptyUiPermissions = Object.freeze({
+  auditlog: [],
+  deployments: [],
+  groups: Object.freeze({}),
+  releases: Object.freeze({}),
+  tenantManagement: [],
+  userManagement: []
+});
+var emptyRole = Object.freeze({
+  name: void 0,
+  description: "",
+  permissions: [],
+  uiPermissions: Object.freeze({ ...emptyUiPermissions })
+});
+
+// src/appSlice/constants.ts
+var import_icons_material = require("@mui/icons-material");
+var startingDeviceCount = {
+  os: "for first 50 devices",
+  professional: "for first 250 devices"
+};
+var apiRoot = "/api/management";
+var apiUrl = {
+  v1: `${apiRoot}/v1`,
+  v2: `${apiRoot}/v2`
+};
+var chartTypes = {
+  bar: { key: "bar", Icon: import_icons_material.BarChart },
+  pie: { key: "pie", Icon: import_icons_material.PieChartOutline }
+};
+var emptyChartSelection = { software: "", group: "", chartType: chartTypes.bar.key, attribute: "artifact_name" };
+var defaultReportType = "distribution";
+var defaultReports = [{ ...emptyChartSelection, group: null, attribute: "artifact_name", type: defaultReportType }];
+var PLANS = {
+  os: {
+    id: "os",
+    name: "Basic",
+    offer: true,
+    price: "$32/month",
+    deviceCount: startingDeviceCount.os,
+    offerprice: "$23/month for first 50 devices",
+    price2: "for first 6 months;\n$29/month thereafter",
+    features: ["Basic OTA features"]
+  },
+  professional: {
+    id: "professional",
+    name: "Professional",
+    offer: true,
+    price: "$269/month",
+    deviceCount: startingDeviceCount.professional,
+    offerprice: "$200/month for first 50 devices",
+    price2: "for first 6 months;\n$249/month thereafter",
+    features: ["+ Advanced OTA features", "+ Standard support"]
+  },
+  enterprise: {
+    id: "enterprise",
+    name: "Enterprise",
+    price: "Custom pricing",
+    deviceCount: "unlimited devices",
+    features: ["+ Enterprise-grade OTA features", "+ Premium support"]
+  }
+};
+var ADDONS = {
+  configure: {
+    id: "configure",
+    title: "Configure",
+    description: "Expand your plan with device configuration features",
+    needs: ["hasDeviceConfig"],
+    os: {
+      price: "$11/month",
+      deviceCount: startingDeviceCount.os
+    },
+    professional: {
+      price: "$65/month",
+      deviceCount: startingDeviceCount.professional
+    },
+    eligible: ["os", "professional", "enterprise"]
+  },
+  troubleshoot: {
+    id: "troubleshoot",
+    title: "Troubleshoot",
+    description: "Expand your plan with device troubleshooting features",
+    needs: ["hasDeviceConnect"],
+    os: {
+      price: "$27/month",
+      deviceCount: startingDeviceCount.os
+    },
+    professional: {
+      price: "$72/month",
+      deviceCount: startingDeviceCount.professional
+    },
+    eligible: ["os", "professional", "enterprise"]
+  },
+  monitor: {
+    id: "monitor",
+    title: "Monitor",
+    description: "Expand your plan with device monitoring features",
+    needs: ["hasMonitor"],
+    os: {
+      price: "-",
+      deviceCount: "-"
+    },
+    professional: {
+      price: "$86/month",
+      deviceCount: startingDeviceCount.professional
+    },
+    eligible: ["professional", "enterprise"]
+  }
+};
+var BENEFITS = {
+  auditlog: { id: "auditlog", benefit: "trace change across your devices and access troubleshooting session replay", requiredPlan: PLANS.professional.id },
+  dashboard: { id: "dashboard", benefit: "actionable insights into the devices you are updating with Mender", requiredPlan: PLANS.enterprise.id },
+  deltaGeneration: {
+    id: "deltaGeneration",
+    benefit: "automatic delta artifacts generation to minimize data transfer and improve the update delivery",
+    requiredPlan: PLANS.enterprise.id
+  },
+  deviceConfiguration: { id: "deviceConfiguration", benefit: "device configuration features", requiredAddon: ADDONS.configure.id },
+  deviceMonitor: { id: "deviceMonitor", benefit: "device monitoring features", requiredAddon: ADDONS.monitor.id, requiredPlan: PLANS.professional.id },
+  deviceTroubleshoot: { id: "deviceTroubleshoot", benefit: "device troubleshooting features", requiredAddon: ADDONS.troubleshoot.id },
+  dynamicGroups: { id: "dynamicGroups", benefit: "create dynamic groups to ease device management", requiredPlan: PLANS.enterprise.id },
+  fullFiltering: { id: "fullFiltering", benefit: "filtering by multiple attributes to improve the device overview", requiredPlan: PLANS.professional.id },
+  gateway: { id: "gateway", benefit: "see devices connected to your gateway device for easy access", requiredPlans: PLANS.professional.id },
+  pausedDeployments: {
+    id: "pausedDeployments",
+    benefit: "granular control about update rollout to allow synchronization across your fleet",
+    requiredPlan: PLANS.enterprise.id
+  },
+  phasedDeployments: { id: "phasedDeployments", benefit: "choose to roll out deployments in multiple phases", requiredPlan: PLANS.enterprise.id },
+  rbac: { id: "rbac", benefit: "granular role based access control", requiredPlan: PLANS.enterprise.id },
+  retryDeployments: { id: "retryDeployments", benefit: "optional retries for failed rollout attempts", requiredPlan: PLANS.professional.id },
+  scheduledDeployments: {
+    id: "scheduledDeployments",
+    benefit: "scheduled deployments to steer the distribution of your updates.",
+    requiredPlan: PLANS.professional.id
+  },
+  webhookEvents: {
+    id: "webhookEvents",
+    benefit: "receive inventory events and select which type(s) of events the webhook will receive",
+    requiredPlan: PLANS.professional.id
+  },
+  default: { id: "default", benefit: "gain access to this feature", requiredPlan: PLANS.enterprise.id }
+};
+var DARK_MODE = "dark";
+
+// src/deploymentsSlice/constants.ts
+var alreadyInstalled = "already-installed";
+var deploymentsApiUrl = `${apiUrl.v1}/deployments`;
+var deploymentsApiUrlV2 = `${apiUrl.v2}/deployments`;
+var deploymentSubstates = {
+  aborted: "aborted",
+  alreadyInstalled,
+  decommissioned: "decommissioned",
+  downloading: "downloading",
+  failure: "failure",
+  installing: "installing",
+  noartifact: "noartifact",
+  pause_before_committing: "pause_before_committing",
+  pause_before_installing: "pause_before_installing",
+  pause_before_rebooting: "pause_before_rebooting",
+  pending: "pending",
+  rebooting: "rebooting",
+  success: "success"
+};
+var deploymentStatesToSubstates = {
+  failures: [deploymentSubstates.failure, deploymentSubstates.aborted, deploymentSubstates.decommissioned],
+  inprogress: [deploymentSubstates.downloading, deploymentSubstates.installing, deploymentSubstates.rebooting],
+  paused: [deploymentSubstates.pause_before_installing, deploymentSubstates.pause_before_rebooting, deploymentSubstates.pause_before_committing],
+  pending: [deploymentSubstates.pending],
+  successes: [deploymentSubstates.success, deploymentSubstates.alreadyInstalled, deploymentSubstates.noartifact]
+};
+var deploymentStatesToSubstatesWithSkipped = {
+  ...deploymentStatesToSubstates,
+  failures: [deploymentSubstates.failure],
+  skipped: [deploymentSubstates.aborted, deploymentSubstates.noartifact, deploymentSubstates.alreadyInstalled, deploymentSubstates.decommissioned],
+  successes: [deploymentSubstates.success]
+};
+var installationSubstatesMap = {
+  download: {
+    title: "download",
+    done: "downloaded",
+    successIndicators: [deploymentSubstates.installing, deploymentSubstates.rebooting, ...deploymentStatesToSubstates.paused, deploymentSubstates.success],
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: "ArtifactInstall_Enter"
+  },
+  install: {
+    title: "install",
+    done: "installed",
+    successIndicators: [
+      deploymentSubstates.rebooting,
+      deploymentSubstates.pause_before_rebooting,
+      deploymentSubstates.pause_before_committing,
+      deploymentSubstates.success
+    ],
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: "ArtifactReboot_Enter"
+  },
+  reboot: {
+    title: "reboot",
+    done: "rebooted",
+    successIndicators: [deploymentSubstates.pause_before_committing, deploymentSubstates.success],
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: "ArtifactCommit_Enter"
+  },
+  commit: {
+    title: "commit",
+    done: "committed",
+    successIndicators: deploymentStatesToSubstates.successes,
+    failureIndicators: deploymentStatesToSubstates.failures,
+    pauseConfigurationIndicator: void 0
+  }
+};
+var DEPLOYMENT_STATES = {
+  finished: "finished",
+  inprogress: "inprogress",
+  pending: "pending",
+  scheduled: "scheduled"
+};
+var listDefaultsByState = {
+  [DEPLOYMENT_STATES.inprogress]: { page: 1, perPage: 10 },
+  [DEPLOYMENT_STATES.pending]: { page: 1, perPage: 10 },
+  [DEPLOYMENT_STATES.scheduled]: { ...DEVICE_LIST_DEFAULTS },
+  [DEPLOYMENT_STATES.finished]: { ...DEVICE_LIST_DEFAULTS },
+  sort: { direction: SORTING_OPTIONS.desc }
+};
+var DEPLOYMENT_ROUTES = {
+  active: {
+    key: "active",
+    route: "/deployments/active",
+    states: [DEPLOYMENT_STATES.pending, DEPLOYMENT_STATES.inprogress],
+    title: "Active"
+  },
+  finished: {
+    key: "finished",
+    route: "/deployments/finished",
+    states: [DEPLOYMENT_STATES.finished],
+    title: "Finished"
+  },
+  scheduled: {
+    key: "scheduled",
+    route: "/deployments/scheduled",
+    states: [DEPLOYMENT_STATES.scheduled],
+    title: "Scheduled"
+  }
+};
+var defaultStats = {
+  [deploymentSubstates.aborted]: 0,
+  [deploymentSubstates.alreadyInstalled]: 0,
+  [deploymentSubstates.decommissioned]: 0,
+  [deploymentSubstates.downloading]: 0,
+  [deploymentSubstates.failure]: 0,
+  [deploymentSubstates.installing]: 0,
+  [deploymentSubstates.noartifact]: 0,
+  [deploymentSubstates.pause_before_committing]: 0,
+  [deploymentSubstates.pause_before_installing]: 0,
+  [deploymentSubstates.pause_before_rebooting]: 0,
+  [deploymentSubstates.pending]: 0,
+  [deploymentSubstates.rebooting]: 0,
+  [deploymentSubstates.success]: 0
+};
+var deploymentDisplayStates = {
+  finished: "Finished",
+  scheduled: "Scheduled",
+  skipped: "Skipped",
+  paused: "Paused",
+  pending: "Pending",
+  inprogress: "In Progress",
+  success: "Success",
+  successes: "Success",
+  failure: "Fail",
+  failures: "Fail"
+};
+var pauseMap = {
+  [deploymentSubstates.pause_before_installing]: {
+    title: installationSubstatesMap.download.done,
+    followUp: installationSubstatesMap.download.pauseConfigurationIndicator
+  },
+  [deploymentSubstates.pause_before_rebooting]: {
+    title: installationSubstatesMap.install.done,
+    followUp: installationSubstatesMap.install.pauseConfigurationIndicator
+  },
+  [deploymentSubstates.pause_before_committing]: {
+    title: installationSubstatesMap.reboot.done,
+    followUp: installationSubstatesMap.reboot.pauseConfigurationIndicator
+  }
+};
+
+// src/devicesSlice/constants.ts
+var emptyFilter = { key: null, value: "", operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "inventory" };
+var deviceAuthV2 = `${apiUrl.v2}/devauth`;
+var deviceConnect = `${apiUrl.v1}/deviceconnect`;
+var inventoryApiUrl = `${apiUrl.v1}/inventory`;
+var inventoryApiUrlV2 = `${apiUrl.v2}/inventory`;
+var deviceConfig = `${apiUrl.v1}/deviceconfig/configurations/device`;
+var reportingApiUrl = `${apiUrl.v1}/reporting`;
+var iotManagerBaseURL = `${apiUrl.v1}/iot-manager`;
+var geoAttributes = ["geo-lat", "geo-lon"].map((attribute) => ({ attribute, scope: "inventory" }));
+
+// src/utils.ts
+var filterProcessors = {
+  $gt: (val) => Number(val) || val,
+  $gte: (val) => Number(val) || val,
+  $lt: (val) => Number(val) || val,
+  $lte: (val) => Number(val) || val,
+  $in: (val) => ("" + val).split(",").map((i) => i.trim()),
+  $nin: (val) => ("" + val).split(",").map((i) => i.trim()),
+  $exists: import_helpers.yes,
+  $nexists: () => false
+};
+var filterAliases = {
+  $nexists: { alias: DEVICE_FILTERING_OPTIONS.$exists.key, value: false }
+};
+var mapFiltersToTerms = (filters) => filters.map((filter) => ({
+  scope: filter.scope,
+  attribute: filter.key,
+  type: filterAliases[filter.operator]?.alias || filter.operator,
+  value: filterProcessors.hasOwnProperty(filter.operator) ? filterProcessors[filter.operator](filter.value) : filter.value
+}));
+var mapTermsToFilters = (terms) => terms.map((term) => {
+  const aliasedFilter = Object.entries(filterAliases).find(
+    (aliasDefinition) => aliasDefinition[1].alias === term.type && aliasDefinition[1].value === term.value
+  );
+  const operator = aliasedFilter ? aliasedFilter[0] : term.type;
+  return { scope: term.scope, key: term.attribute, operator, value: term.value };
+});
+var convertIssueOptionsToFilters = (issuesSelection, filtersState = {}) => issuesSelection.map((item) => {
+  if (typeof DEVICE_ISSUE_OPTIONS[item].filterRule.value === "function") {
+    return { ...DEVICE_ISSUE_OPTIONS[item].filterRule, value: DEVICE_ISSUE_OPTIONS[item].filterRule.value(filtersState) };
+  }
+  return DEVICE_ISSUE_OPTIONS[item].filterRule;
+});
+var convertDeviceListStateToFilters = ({ filters = [], group, groups = { byId: {} }, offlineThreshold, selectedIssues = [], status }) => {
+  let applicableFilters = [...filters];
+  if (typeof group === "string" && !(groups.byId[group]?.filters || applicableFilters).length) {
+    applicableFilters.push({ key: "group", value: group, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "system" });
+  }
+  const nonMonitorFilters = applicableFilters.filter(
+    (filter) => !Object.values(DEVICE_ISSUE_OPTIONS).some(
+      ({ filterRule }) => filter.scope !== "inventory" && filterRule.scope === filter.scope && filterRule.key === filter.key
+    )
+  );
+  const deviceIssueFilters = convertIssueOptionsToFilters(selectedIssues, { offlineThreshold });
+  applicableFilters = [...nonMonitorFilters, ...deviceIssueFilters];
+  const effectiveFilters = status ? [...applicableFilters, { key: "status", value: status, operator: DEVICE_FILTERING_OPTIONS.$eq.key, scope: "identity" }] : applicableFilters;
+  return { applicableFilters: nonMonitorFilters, filterTerms: mapFiltersToTerms(effectiveFilters) };
+};
+var filterCompare = (filter, item) => Object.keys(emptyFilter).every((key) => item[key].toString() === filter[key].toString());
+var filtersFilter = (item, index, array) => {
+  const firstIndex = array.findIndex((filter) => filterCompare(filter, item));
+  return firstIndex === index;
+};
+var listItemMapper = (byId, ids, { defaultObject = {}, cutOffSize = DEVICE_LIST_MAXIMUM_LENGTH }) => {
+  return ids.slice(0, cutOffSize).reduce((accu, id) => {
+    if (id && byId[id]) {
+      accu.push({ ...defaultObject, ...byId[id] });
+    }
+    return accu;
+  }, []);
+};
+var mergePermissions = (existingPermissions = { ...emptyUiPermissions }, addedPermissions) => Object.entries(existingPermissions).reduce(
+  (accu, [key, value]) => {
+    let values;
+    if (!accu[key]) {
+      accu[key] = value;
+      return accu;
+    }
+    if (Array.isArray(value)) {
+      values = [...value, ...accu[key]].filter(import_helpers.duplicateFilter);
+    } else {
+      values = mergePermissions(accu[key], { ...value });
+    }
+    accu[key] = values;
+    return accu;
+  },
+  { ...addedPermissions }
+);
+var mapUserRolesToUiPermissions = (userRoles, roles) => userRoles.reduce(
+  (accu, roleId) => {
+    if (!(roleId && roles[roleId])) {
+      return accu;
+    }
+    return mergePermissions(accu, roles[roleId].uiPermissions);
+  },
+  { ...emptyUiPermissions }
+);
+var progress = ({ loaded, total }) => {
+  let uploadProgress = loaded / total * 100;
+  return uploadProgress = uploadProgress < 50 ? Math.ceil(uploadProgress) : Math.round(uploadProgress);
+};
+var getComparisonCompatibleVersion = (version) => isNaN(version.charAt(0)) && version !== "next" ? "master" : version;
+var stringToBoolean = (content) => {
+  if (!content) {
+    return false;
+  }
+  const string = content + "";
+  switch (string.trim().toLowerCase()) {
+    case "true":
+    case "yes":
+    case "1":
+      return true;
+    case "false":
+    case "no":
+    case "0":
+    case null:
+      return false;
+    default:
+      return Boolean(string);
+  }
+};
+var groupDeploymentDevicesStats = (deployment) => {
+  const deviceStatCollector = (deploymentStates, devices) => Object.values(devices).reduce((accu, device) => deploymentStates.includes(device.status) ? accu + 1 : accu, 0);
+  const inprogress = deviceStatCollector(deploymentStatesToSubstates.inprogress, deployment.devices);
+  const pending = deviceStatCollector(deploymentStatesToSubstates.pending, deployment.devices);
+  const successes = deviceStatCollector(deploymentStatesToSubstates.successes, deployment.devices);
+  const failures = deviceStatCollector(deploymentStatesToSubstates.failures, deployment.devices);
+  const paused = deviceStatCollector(deploymentStatesToSubstates.paused, deployment.devices);
+  return { inprogress, paused, pending, successes, failures };
+};
+var statCollector = (items, statistics) => items.reduce((accu, property) => accu + Number(statistics[property] || 0), 0);
+var groupDeploymentStats = (deployment, withSkipped) => {
+  const { statistics = {} } = deployment;
+  const { status = {} } = statistics;
+  const stats = { ...defaultStats, ...status };
+  let groupStates = deploymentStatesToSubstates;
+  let result = {};
+  if (withSkipped) {
+    groupStates = deploymentStatesToSubstatesWithSkipped;
+    result.skipped = statCollector(groupStates.skipped, stats);
+  }
+  result = {
+    ...result,
+    // don't include 'pending' as inprogress, as all remaining devices will be pending - we don't discriminate based on phase membership
+    inprogress: statCollector(groupStates.inprogress, stats),
+    pending: (deployment.max_devices ? deployment.max_devices - deployment.device_count : 0) + statCollector(groupStates.pending, stats),
+    successes: statCollector(groupStates.successes, stats),
+    failures: statCollector(groupStates.failures, stats),
+    paused: statCollector(groupStates.paused, stats)
+  };
+  return result;
+};
+var getDeploymentState = (deployment) => {
+  const { status: deploymentStatus = DEPLOYMENT_STATES.pending } = deployment;
+  const { inprogress: currentProgressCount, paused } = groupDeploymentStats(deployment);
+  let status = deploymentDisplayStates[deploymentStatus];
+  if (deploymentStatus === DEPLOYMENT_STATES.pending && currentProgressCount === 0) {
+    status = "queued";
+  } else if (paused > 0) {
+    status = deploymentDisplayStates.paused;
+  }
+  return status;
+};
+var generateDeploymentGroupDetails = (filter, groupName) => filter && filter.terms?.length ? `${groupName} (${filter.terms.map((filter2) => `${filter2.attribute || filter2.key} ${DEVICE_FILTERING_OPTIONS[filter2.type || filter2.operator].shortform} ${filter2.value}`).join(", ")})` : groupName;
+var mapDeviceAttributes = (attributes = []) => attributes.reduce(
+  (accu, attribute) => {
+    if (!(attribute.value && attribute.name) && attribute.scope === ATTRIBUTE_SCOPES.inventory) {
+      return accu;
+    }
+    accu[attribute.scope || ATTRIBUTE_SCOPES.inventory] = {
+      ...accu[attribute.scope || ATTRIBUTE_SCOPES.inventory],
+      [attribute.name]: attribute.value
+    };
+    if (attribute.name === "device_type" && attribute.scope === ATTRIBUTE_SCOPES.inventory) {
+      accu.inventory.device_type = [].concat(attribute.value);
+    }
+    return accu;
+  },
+  { inventory: { device_type: [], artifact_name: "" }, identity: {}, monitor: {}, system: {}, tags: {} }
+);
+var isDarkMode = (mode) => mode === DARK_MODE;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertDeviceListStateToFilters,
+  filtersFilter,
+  generateDeploymentGroupDetails,
+  getComparisonCompatibleVersion,
+  getDeploymentState,
+  groupDeploymentDevicesStats,
+  groupDeploymentStats,
+  isDarkMode,
+  listItemMapper,
+  mapDeviceAttributes,
+  mapFiltersToTerms,
+  mapTermsToFilters,
+  mapUserRolesToUiPermissions,
+  mergePermissions,
+  progress,
+  statCollector,
+  stringToBoolean
+});
+//# sourceMappingURL=utils.cjs.map