poi-plugin-remodel-assistant 0.1.19-beta

package/views/new-interface/equipment/modals/equipment-category-filter-modal.js

@@ -0,0 +1,261 @@
+"use strict";
+
+exports.__esModule = true;
+exports.EquipmentCategoryFilterModal = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _reactBootstrap = require("react-bootstrap");
+
+var _icon = require("views/components/etc/icon");
+
+var _pluginMeta = require("../../../shared/plugin-meta");
+
+var _multiSelectionModel = require("../../shared/model/multi-selection-model");
+
+var _equipmentCategoryModel = require("../model/equipment-category-model");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+const {
+  __: translate
+} = window.i18n[_pluginMeta.PLUGIN_ID];
+
+const __ = (key, ...args) => translate(`equipment.${key}`, ...args);
+
+const categoryName = category => category.i18nKey === 'Equipment category %d' ? __(category.i18nKey).replace('%d', category.id) : __(category.i18nKey);
+
+class EquipmentCategoryFilterModal extends _react.Component {
+  constructor(props) {
+    super(props);
+    Object.defineProperty(this, "handleEnter", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => {
+        const {
+          selectedCategoryIds
+        } = this.props;
+        this.setState({
+          draftCategoryIds: (0, _equipmentCategoryModel.normalizeCategoryIds)(selectedCategoryIds)
+        });
+      }
+    });
+    Object.defineProperty(this, "handleToggle", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: (categoryId, event = {}) => {
+        const {
+          categories
+        } = this.props;
+        this.setState(state => {
+          const checked = !state.draftCategoryIds.includes(categoryId);
+          const selected = state.draftCategoryIds.reduce((result, id) => _extends({}, result, {
+            [String(id)]: true
+          }), {});
+          const shiftKey = Boolean(event.shiftKey || event.nativeEvent && event.nativeEvent.shiftKey);
+          const next = shiftKey && this.selectionAnchor !== null ? (0, _multiSelectionModel.updateRangeSelection)({
+            selected,
+            orderedKeys: categories.map(category => category.id),
+            anchorKey: this.selectionAnchor,
+            key: categoryId,
+            checked
+          }) : _extends({}, selected, {
+            [String(categoryId)]: checked
+          });
+          if (!shiftKey) this.selectionAnchor = categoryId;
+          return {
+            draftCategoryIds: (0, _equipmentCategoryModel.normalizeCategoryIds)(Object.keys(next).filter(key => next[key]).map(Number))
+          };
+        });
+      }
+    });
+    Object.defineProperty(this, "handleSelectAll", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => {
+        const {
+          categories
+        } = this.props;
+        this.setState({
+          draftCategoryIds: (0, _equipmentCategoryModel.normalizeCategoryIds)(categories.map(category => category.id))
+        });
+      }
+    });
+    Object.defineProperty(this, "handleGroupToggle", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: categories => {
+        const ids = categories.map(category => category.id);
+        this.setState(state => {
+          const selected = new Set(state.draftCategoryIds);
+          const allSelected = ids.every(id => selected.has(id));
+          ids.forEach(id => {
+            if (allSelected) selected.delete(id);else selected.add(id);
+          });
+          return {
+            draftCategoryIds: (0, _equipmentCategoryModel.normalizeCategoryIds)(Array.from(selected))
+          };
+        });
+      }
+    });
+    Object.defineProperty(this, "handleClear", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => {
+        this.setState({
+          draftCategoryIds: []
+        });
+      }
+    });
+    Object.defineProperty(this, "handleApply", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => {
+        const {
+          onApply
+        } = this.props;
+        const {
+          draftCategoryIds
+        } = this.state;
+        onApply(draftCategoryIds);
+      }
+    });
+    Object.defineProperty(this, "renderCategory", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: category => {
+        const {
+          draftCategoryIds
+        } = this.state;
+        const checked = draftCategoryIds.includes(category.id);
+        const inputId = `decision-category-filter-${category.id}`;
+        return _react.default.createElement("div", {
+          className: `equipment-category-option${checked ? ' is-selected' : ''}`,
+          key: category.id
+        }, _react.default.createElement("label", {
+          className: "equipment-category-option-control",
+          htmlFor: inputId
+        }, _react.default.createElement("input", {
+          id: inputId,
+          type: "checkbox",
+          checked: checked,
+          onChange: event => this.handleToggle(category.id, event)
+        }), _react.default.createElement("span", {
+          className: "equipment-category-option-icon-frame",
+          "aria-hidden": "true"
+        }, _react.default.createElement(_icon.SlotitemIcon, {
+          slotitemId: category.iconId,
+          className: "equip-icon equipment-category-slotitem-icon"
+        })), _react.default.createElement("strong", {
+          className: "equipment-category-option-name",
+          title: categoryName(category)
+        }, categoryName(category)), _react.default.createElement("span", {
+          className: "equipment-category-option-count"
+        }, category.count)));
+      }
+    });
+    this.state = {
+      draftCategoryIds: (0, _equipmentCategoryModel.normalizeCategoryIds)(props.selectedCategoryIds)
+    };
+  }
+
+  render() {
+    const {
+      show,
+      categories,
+      onHide
+    } = this.props;
+    const {
+      draftCategoryIds
+    } = this.state;
+    const groups = (0, _equipmentCategoryModel.buildEquipmentCategoryGroups)(categories);
+    return _react.default.createElement(_reactBootstrap.Modal, {
+      show: show,
+      onEnter: this.handleEnter,
+      onHide: onHide,
+      className: "decision-category-filter-modal",
+      bsSize: "large",
+      dialogClassName: "decision-category-filter-dialog"
+    }, _react.default.createElement(_reactBootstrap.Modal.Header, {
+      closeButton: true
+    }, _react.default.createElement(_reactBootstrap.Modal.Title, null, __('Equipment category'))), _react.default.createElement(_reactBootstrap.Modal.Body, {
+      className: "equipment-category-body"
+    }, _react.default.createElement("div", {
+      className: "equipment-category-guide"
+    }, _react.default.createElement("span", {
+      className: "glyphicon glyphicon-info-sign",
+      "aria-hidden": "true"
+    }), _react.default.createElement("span", null, __('Categories are grouped by combat role; multi-select uses OR')), _react.default.createElement("strong", null, draftCategoryIds.length > 0 ? __('Selected %d').replace('%d', draftCategoryIds.length) : __('All categories')), _react.default.createElement(_reactBootstrap.Button, {
+      bsSize: "xsmall",
+      onClick: this.handleSelectAll,
+      disabled: categories.length === 0 || draftCategoryIds.length === categories.length
+    }, __('Select all')), _react.default.createElement(_reactBootstrap.Button, {
+      bsSize: "xsmall",
+      onClick: this.handleClear,
+      disabled: draftCategoryIds.length === 0
+    }, __('Clear'))), _react.default.createElement("div", {
+      className: "equipment-category-board"
+    }, groups.map(group => {
+      const selectedCount = group.categories.filter(category => draftCategoryIds.includes(category.id)).length;
+      const allSelected = selectedCount === group.categories.length;
+      return _react.default.createElement("section", {
+        className: `equipment-category-panel is-${group.key}`,
+        key: group.key
+      }, _react.default.createElement("header", null, _react.default.createElement("button", {
+        type: "button",
+        className: `equipment-category-panel-toggle${allSelected ? ' is-selected' : selectedCount > 0 ? ' is-partial' : ''}`,
+        "aria-pressed": allSelected,
+        onClick: () => this.handleGroupToggle(group.categories)
+      }, _react.default.createElement("span", {
+        className: `glyphicon glyphicon-${allSelected ? 'check' : selectedCount > 0 ? 'minus' : 'unchecked'}`,
+        "aria-hidden": "true"
+      }), _react.default.createElement("strong", null, __(group.label)), _react.default.createElement("small", null, __('Selected %d of %s').replace('%d', selectedCount).replace('%s', group.categories.length)), _react.default.createElement("span", null, group.count))), _react.default.createElement("div", {
+        className: "equipment-category-options"
+      }, group.categories.map(this.renderCategory)));
+    })), categories.length === 0 && _react.default.createElement("div", {
+      className: "decision-empty-state"
+    }, __('No equipment categories are available'))), _react.default.createElement(_reactBootstrap.Modal.Footer, null, _react.default.createElement(_reactBootstrap.Button, {
+      onClick: this.handleClear,
+      disabled: draftCategoryIds.length === 0
+    }, __('Clear')), _react.default.createElement(_reactBootstrap.Button, {
+      onClick: onHide
+    }, __('Cancel')), _react.default.createElement(_reactBootstrap.Button, {
+      bsStyle: "primary",
+      onClick: this.handleApply
+    }, draftCategoryIds.length > 0 ? __('Apply %d').replace('%d', draftCategoryIds.length) : __('All categories'))));
+  }
+
+}
+
+exports.EquipmentCategoryFilterModal = EquipmentCategoryFilterModal;
+Object.defineProperty(EquipmentCategoryFilterModal, "propTypes", {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  value: {
+    show: _propTypes.default.bool.isRequired,
+    categories: _propTypes.default.arrayOf(_propTypes.default.shape({
+      id: _propTypes.default.number.isRequired,
+      name: _propTypes.default.string.isRequired,
+      i18nKey: _propTypes.default.string.isRequired,
+      count: _propTypes.default.number.isRequired,
+      iconId: _propTypes.default.number.isRequired
+    })).isRequired,
+    selectedCategoryIds: _propTypes.default.arrayOf(_propTypes.default.number).isRequired,
+    onApply: _propTypes.default.func.isRequired,
+    onHide: _propTypes.default.func.isRequired
+  }
+});

package/views/new-interface/equipment/model/equipment-blacklist-model.js

@@ -0,0 +1,422 @@
+"use strict";
+
+exports.__esModule = true;
+exports.sortBlacklistEntries = exports.buildExclusionReasonItems = exports.prewarmExclusionRecommendationSnapshot = exports.buildExclusionRecommendations = exports.buildDirectUpgradeEvidence = exports.buildEquipmentMaterialConsumerIndex = exports.buildDirectUpgradeTargetIds = exports.compareExclusionRecommendations = exports.selectEffectiveImprovementData = exports.loadEquipmentSourcesIndex = exports.loadEquipmentDropFromIndex = exports.invalidateEquipmentBlacklistCaches = exports.buildManualBlacklistCandidates = exports.buildManualBlacklistEligibleIds = exports.isPlayerEquipmentMaster = exports.getEquipmentRare = exports.getEquipmentTypeId = exports.DEFAULT_BLACKLIST_SORT_MODE = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _dataPackage = require("../../../shared/data-package");
+
+var _equipmentBlacklistStorage = require("../../../shared/equipment-blacklist-storage");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+const EMPTY_QUEST_SOURCES = Object.freeze({});
+const DEFAULT_BLACKLIST_SORT_MODE = 'type';
+exports.DEFAULT_BLACKLIST_SORT_MODE = DEFAULT_BLACKLIST_SORT_MODE;
+let cachedDropFromIdentity = '';
+let cachedDropFromIndex = {};
+let cachedEquipmentSourcesIdentity = '';
+let cachedEquipmentSourcesIndex = {};
+let effectiveCache = null;
+let recommendationCache = null;
+
+const masterEntry = (values, id) => (values || {})[id] || (values || {})[String(id)] || {};
+
+const getEquipmentTypeId = (equipmentId, masterEquips = {}) => {
+  const master = masterEntry(masterEquips, Number(equipmentId));
+  return Number(master.api_type && master.api_type[2]) || 0;
+};
+
+exports.getEquipmentTypeId = getEquipmentTypeId;
+
+const getEquipmentRare = (equipmentId, masterEquips = {}) => {
+  const master = masterEntry(masterEquips, Number(equipmentId));
+  const rare = Number(master.api_rare);
+  return Number.isFinite(rare) ? rare : null;
+};
+
+exports.getEquipmentRare = getEquipmentRare;
+
+const isPlayerEquipmentMaster = master => Boolean(master) && Number(master.api_sortno) > 0 && String(master.api_name || '').trim().length > 0;
+
+exports.isPlayerEquipmentMaster = isPlayerEquipmentMaster;
+
+const hasImprovement = row => Array.isArray(row && row.improvementList) && row.improvementList.length > 0;
+
+const buildManualBlacklistEligibleIds = (data = []) => {
+  const eligibleIds = new Set();
+  const rows = Array.isArray(data) ? data : [];
+  rows.forEach(row => {
+    const equipmentId = Number(row && row.id);
+
+    if (Number.isInteger(equipmentId) && equipmentId > 0 && hasImprovement(row)) {
+      eligibleIds.add(equipmentId);
+    }
+
+    const routes = row && row.improvementList || [];
+    routes.forEach(route => {
+      const stages = route && route.stageList || [];
+      stages.forEach(stage => {
+        const targetId = Number(stage && stage.targetWeapon && stage.targetWeapon.id);
+        if (Number.isInteger(targetId) && targetId > 0) eligibleIds.add(targetId);
+      });
+    });
+  });
+  return eligibleIds;
+};
+
+exports.buildManualBlacklistEligibleIds = buildManualBlacklistEligibleIds;
+
+const buildManualBlacklistCandidates = (blacklist = {}, masterEquips = {}, data = []) => {
+  const entries = blacklist && blacklist.entries || {};
+  const blockedIds = new Set();
+  Object.keys(entries).forEach(key => {
+    const entry = entries[key] || {};
+    const candidateIds = [key, entry.equipmentId];
+    candidateIds.forEach(value => {
+      const equipmentId = Number(value);
+      if (Number.isInteger(equipmentId) && equipmentId > 0) blockedIds.add(equipmentId);
+    });
+  });
+  const eligibleIds = buildManualBlacklistEligibleIds(data);
+  return Object.keys(masterEquips || {}).map(Number).filter(equipmentId => Number.isInteger(equipmentId) && equipmentId > 0 && eligibleIds.has(equipmentId) && !blockedIds.has(equipmentId) && isPlayerEquipmentMaster(masterEntry(masterEquips, equipmentId))).map(equipmentId => ({
+    equipmentId,
+    source: 'manual',
+    addedAt: 0
+  }));
+};
+
+exports.buildManualBlacklistCandidates = buildManualBlacklistCandidates;
+
+const loadNedbIndex = filePath => {
+  const index = {};
+
+  _fs.default.readFileSync(filePath, 'utf8').split(/\r?\n/).filter(Boolean).forEach(line => {
+    const record = JSON.parse(line);
+    const equipmentId = Number(record && record.equipmentId);
+    if (equipmentId > 0) index[equipmentId] = record;
+  });
+
+  return index;
+};
+
+const dataFileIdentity = datasetName => {
+  const root = (0, _dataPackage.getActiveDataPackageRoot)();
+  const manifest = (0, _dataPackage.getDataPackageManifest)();
+  const dataset = manifest.datasets && manifest.datasets[datasetName] || {};
+  const relative = String(dataset.path || '');
+  const file = manifest.files && manifest.files[relative] || {};
+  return [root, String(manifest.packageVersion || ''), relative, String(file.sha256 || '')].join('\0');
+};
+
+const invalidateEquipmentBlacklistCaches = () => {
+  cachedDropFromIdentity = '';
+  cachedDropFromIndex = {};
+  cachedEquipmentSourcesIdentity = '';
+  cachedEquipmentSourcesIndex = {};
+  effectiveCache = null;
+  recommendationCache = null;
+};
+
+exports.invalidateEquipmentBlacklistCaches = invalidateEquipmentBlacklistCaches;
+
+const loadEquipmentDropFromIndex = () => {
+  const identity = dataFileIdentity('equipmentDropFrom');
+  if (cachedDropFromIdentity === identity) return cachedDropFromIndex;
+  cachedDropFromIdentity = identity;
+  cachedDropFromIndex = loadNedbIndex((0, _dataPackage.getEquipmentDropFromPath)());
+  return cachedDropFromIndex;
+};
+
+exports.loadEquipmentDropFromIndex = loadEquipmentDropFromIndex;
+
+const loadEquipmentSourcesIndex = () => {
+  const identity = dataFileIdentity('equipmentSources');
+  if (cachedEquipmentSourcesIdentity === identity) return cachedEquipmentSourcesIndex;
+  cachedEquipmentSourcesIdentity = identity;
+  cachedEquipmentSourcesIndex = loadNedbIndex((0, _dataPackage.getEquipmentSourcesPath)());
+  return cachedEquipmentSourcesIndex;
+};
+
+exports.loadEquipmentSourcesIndex = loadEquipmentSourcesIndex;
+
+const blacklistSignature = blacklist => (0, _equipmentBlacklistStorage.getEquipmentBlacklistIds)(blacklist).join(',');
+
+const selectEffectiveImprovementData = (data = [], blacklist = {}) => {
+  const signature = blacklistSignature(blacklist);
+
+  if (effectiveCache && effectiveCache.data === data && effectiveCache.signature === signature) {
+    return effectiveCache.value;
+  }
+
+  const excluded = new Set(signature ? signature.split(',').map(Number) : []);
+  const value = (data || []).filter(row => !excluded.has(Number(row && row.id))).map(row => {
+    let changed = false;
+    const improvementList = (row.improvementList || []).map(route => {
+      const stageList = (route.stageList || []).filter(stage => !excluded.has(Number(stage && stage.targetWeapon && stage.targetWeapon.id)));
+      if (stageList.length !== (route.stageList || []).length) changed = true;
+      return stageList.length === (route.stageList || []).length ? route : _extends({}, route, {
+        stageList
+      });
+    }).filter(route => (route.stageList || []).length > 0);
+    if (improvementList.length !== (row.improvementList || []).length) changed = true;
+    return changed ? _extends({}, row, {
+      improvementList
+    }) : row;
+  });
+  effectiveCache = {
+    data,
+    signature,
+    value
+  };
+  return value;
+};
+
+exports.selectEffectiveImprovementData = selectEffectiveImprovementData;
+
+const sourceKindsPriority = kinds => {
+  const hasDevelopment = kinds.includes('development');
+  const hasShip = kinds.includes('ship');
+  const hasQuest = kinds.includes('quest');
+  if (hasDevelopment && (hasShip || hasQuest)) return 0;
+  if (hasDevelopment) return 1;
+  if (hasShip && hasQuest) return 2;
+  if (hasShip) return 3;
+  if (hasQuest) return 4;
+  return 5;
+};
+
+const compareExclusionRecommendations = (left, right, masterEquips = {}, sortMode = 'recommended') => {
+  const nameOf = item => String(masterEntry(masterEquips, item.equipmentId).api_name || item.equipmentName || '');
+
+  const typeDifference = getEquipmentTypeId(left.equipmentId, masterEquips) - getEquipmentTypeId(right.equipmentId, masterEquips);
+  const leftRare = getEquipmentRare(left.equipmentId, masterEquips);
+  const rightRare = getEquipmentRare(right.equipmentId, masterEquips);
+  const rareDifference = (rightRare == null ? -1 : rightRare) - (leftRare == null ? -1 : leftRare);
+  const nameDifference = nameOf(left).localeCompare(nameOf(right));
+  if (sortMode === 'type') return typeDifference || rareDifference || nameDifference || left.equipmentId - right.equipmentId;
+  if (sortMode === 'rarity') return rareDifference || typeDifference || nameDifference || left.equipmentId - right.equipmentId;
+  if (sortMode === 'name') return nameDifference || typeDifference || left.equipmentId - right.equipmentId;
+  return sourceKindsPriority(left.sourceKinds) - sourceKindsPriority(right.sourceKinds) || typeDifference || rareDifference || nameDifference || left.equipmentId - right.equipmentId;
+};
+
+exports.compareExclusionRecommendations = compareExclusionRecommendations;
+
+const buildDirectUpgradeTargetIds = row => {
+  const targetIds = new Set();
+  const routes = row && row.improvementList || [];
+  routes.forEach(route => {
+    const stages = route && route.stageList || [];
+    stages.forEach(stage => {
+      const targetId = Number(stage && stage.targetWeapon && stage.targetWeapon.id);
+      if (Number.isInteger(targetId) && targetId > 0) targetIds.add(targetId);
+    });
+  });
+  return Array.from(targetIds).sort((left, right) => left - right);
+};
+
+exports.buildDirectUpgradeTargetIds = buildDirectUpgradeTargetIds;
+
+const buildEquipmentMaterialConsumerIndex = (data = []) => {
+  const result = {};
+  const rows = data || [];
+  rows.forEach(row => {
+    const consumerId = Number(row && row.id);
+    if (!Number.isInteger(consumerId) || consumerId <= 0) return;
+    const routes = row && row.improvementList || [];
+    routes.forEach(route => {
+      const stages = route && route.stageList || [];
+      stages.forEach(stage => {
+        const consumables = stage && stage.consumables || [];
+        consumables.forEach(consumable => {
+          const materialId = Number(consumable && consumable.id);
+          const materialType = Number(consumable && consumable.type);
+          if (!Number.isInteger(materialId) || materialId <= 0 || materialType !== 0) return;
+          result[materialId] = result[materialId] || new Set();
+          result[materialId].add(consumerId);
+        });
+      });
+    });
+  });
+  return result;
+}; // This index must already contain recurring quests only. sources.nedb questKey
+// proves a quest source exists, but does not classify its cadence.
+
+
+exports.buildEquipmentMaterialConsumerIndex = buildEquipmentMaterialConsumerIndex;
+
+const periodicQuestSources = (targetId, questSourcesByTarget) => ((questSourcesByTarget || {})[Number(targetId)] || []).slice();
+
+const consumedByOtherImprovement = (targetId, materialConsumers) => Array.from((materialConsumers || {})[Number(targetId)] || []).some(consumerId => Number(consumerId) !== Number(targetId));
+
+const buildDirectUpgradeEvidence = ({
+  targetId,
+  equipmentSourcesIndex,
+  questSourcesByTarget = EMPTY_QUEST_SOURCES,
+  materialConsumers
+}) => {
+  const record = (equipmentSourcesIndex || {})[Number(targetId)] || {};
+  const source = record.source || {};
+  const developmentAvailable = source.developmentAvailable === true;
+  const shipIds = Array.from(new Set((source.shipIds || []).map(Number).filter(shipId => Number.isInteger(shipId) && shipId > 0)));
+  const shipAvailable = shipIds.length > 0;
+  const questSources = periodicQuestSources(targetId, questSourcesByTarget);
+  const hasPeriodicQuest = questSources.length > 0;
+  const consumedByOther = consumedByOtherImprovement(targetId, materialConsumers);
+  const repeatableSourceAvailable = shipAvailable || hasPeriodicQuest;
+  const lowValueBy = developmentAvailable ? 'development' : repeatableSourceAvailable && !consumedByOther ? 'repeatable-source' : null;
+  return {
+    targetEquipmentId: Number(targetId),
+    developmentAvailable,
+    shipAvailable,
+    shipIds,
+    periodicQuestAvailable: hasPeriodicQuest,
+    questSources,
+    consumedByOtherImprovement: consumedByOther,
+    lowValueBy,
+    lowValue: lowValueBy !== null
+  };
+};
+
+exports.buildDirectUpgradeEvidence = buildDirectUpgradeEvidence;
+
+const buildExclusionRecommendations = ({
+  data = [],
+  blacklist = {},
+  masterEquips = {},
+  questSourcesByTarget = EMPTY_QUEST_SOURCES,
+  equipmentSourcesIndex = null
+} = {}) => {
+  const signature = blacklistSignature(blacklist);
+  const sources = equipmentSourcesIndex || loadEquipmentSourcesIndex();
+
+  if (recommendationCache && recommendationCache.data === data && recommendationCache.signature === signature && recommendationCache.masterEquips === masterEquips && recommendationCache.questSourcesByTarget === questSourcesByTarget && recommendationCache.equipmentSourcesIndex === sources) {
+    return recommendationCache.value;
+  }
+
+  const excluded = new Set((0, _equipmentBlacklistStorage.getEquipmentBlacklistIds)(blacklist));
+  const materialConsumers = buildEquipmentMaterialConsumerIndex(data);
+  const value = (data || []).reduce((result, row) => {
+    const equipmentId = Number(row && row.id);
+    if (!equipmentId || excluded.has(equipmentId)) return result;
+    const targetIds = buildDirectUpgradeTargetIds(row);
+    if (targetIds.length === 0) return result;
+    const evidence = targetIds.map(targetId => buildDirectUpgradeEvidence({
+      targetId,
+      equipmentSourcesIndex: sources,
+      questSourcesByTarget,
+      materialConsumers
+    }));
+    if (!evidence.every(item => item.lowValue)) return result;
+    const sourceKinds = [evidence.some(item => item.lowValueBy === 'development') ? 'development' : null, evidence.some(item => item.lowValueBy === 'repeatable-source' && item.shipAvailable) ? 'ship' : null, evidence.some(item => item.lowValueBy === 'repeatable-source' && item.periodicQuestAvailable) ? 'quest' : null].filter(Boolean);
+    return result.concat({
+      equipmentId,
+      equipmentName: String(masterEntry(masterEquips, equipmentId).api_name || row.api_name || ''),
+      sourceKinds,
+      evidence
+    });
+  }, []);
+  recommendationCache = {
+    data,
+    signature,
+    masterEquips,
+    questSourcesByTarget,
+    equipmentSourcesIndex: sources,
+    value
+  };
+  return value;
+};
+
+exports.buildExclusionRecommendations = buildExclusionRecommendations;
+
+const deferRecommendationWork = callback => new Promise((resolve, reject) => {
+  const schedule = typeof setImmediate === 'function' ? setImmediate : setTimeout;
+  schedule(() => {
+    try {
+      resolve(callback());
+    } catch (error) {
+      reject(error);
+    }
+  }, 0);
+});
+
+const prewarmExclusionRecommendationSnapshot = options => deferRecommendationWork(() => ({
+  equipmentSources: loadEquipmentDropFromIndex(),
+  recommendations: buildExclusionRecommendations(options)
+}));
+
+exports.prewarmExclusionRecommendationSnapshot = prewarmExclusionRecommendationSnapshot;
+
+const questSourceIdentity = source => {
+  if (source == null) return '';
+  if (typeof source === 'string' || typeof source === 'number') return String(source);
+  const key = source.questKey || source.questId || source.id || source.code || '';
+  const name = source.questName || source.name || source.title || source.displayName || '';
+  if (key && name) return `${key} ${name}`;
+  return String(name || key || '');
+};
+
+const buildExclusionReasonItems = (recommendation, masterEquips = {}, equipmentDropFromIndex = {}) => (recommendation && recommendation.evidence || []).map(item => {
+  const targetEquipmentId = Number(item && item.targetEquipmentId);
+  const targetName = String(masterEntry(masterEquips, targetEquipmentId).api_name || `#${targetEquipmentId}`);
+  const allowedShipIds = new Set((item.shipIds || []).map(Number));
+  const hasShipEvidence = allowedShipIds.size > 0;
+  const dropRecord = (equipmentDropFromIndex || {})[targetEquipmentId] || (equipmentDropFromIndex || {})[String(targetEquipmentId)] || {};
+  const seenShips = new Set();
+  const shipSources = (hasShipEvidence ? dropRecord.sources || [] : []).filter(source => allowedShipIds.has(Number(source && source.shipId))).reduce((result, source) => {
+    const shipId = Number(source && source.shipId);
+    const shipName = String(source && (source.shipName || source.shipId) || '');
+    if (!shipName) return result;
+    const method = source && source.method === 'remodel' ? 'remodel' : 'initial';
+    const remodelLevel = Number(source && source.remodelLevel) || 0;
+    const identity = `${shipId}:${shipName}:${method}:${remodelLevel}`;
+    if (seenShips.has(identity)) return result;
+    seenShips.add(identity);
+    return result.concat({
+      shipId,
+      shipName,
+      method,
+      remodelLevel
+    });
+  }, []);
+  const seenQuests = new Set();
+  const questSources = (item.questSources || []).reduce((result, source) => {
+    const label = questSourceIdentity(source);
+    if (!label || seenQuests.has(label)) return result;
+    seenQuests.add(label);
+    return result.concat({
+      label,
+      source
+    });
+  }, []);
+  return {
+    targetEquipmentId,
+    targetName,
+    lowValueBy: item.lowValueBy || null,
+    developmentAvailable: item.developmentAvailable === true,
+    shipSources,
+    questSources,
+    consumedByOtherImprovement: item.consumedByOtherImprovement === true
+  };
+});
+
+exports.buildExclusionReasonItems = buildExclusionReasonItems;
+
+const sortBlacklistEntries = (entries = [], masterEquips = {}, sortMode = DEFAULT_BLACKLIST_SORT_MODE) => entries.slice().sort((left, right) => {
+  const leftMaster = masterEntry(masterEquips, left.equipmentId);
+  const rightMaster = masterEntry(masterEquips, right.equipmentId);
+  const typeDifference = getEquipmentTypeId(left.equipmentId, masterEquips) - getEquipmentTypeId(right.equipmentId, masterEquips);
+  const leftRare = getEquipmentRare(left.equipmentId, masterEquips);
+  const rightRare = getEquipmentRare(right.equipmentId, masterEquips);
+  const rareDifference = (rightRare == null ? -1 : rightRare) - (leftRare == null ? -1 : leftRare);
+  const nameDifference = String(leftMaster.api_name || '').localeCompare(String(rightMaster.api_name || ''));
+  if (sortMode === 'type') return typeDifference || rareDifference || nameDifference;
+  if (sortMode === 'rarity') return rareDifference || typeDifference || nameDifference;
+  if (sortMode === 'name') return nameDifference || typeDifference;
+  return String(left.addedAt || '').localeCompare(String(right.addedAt || ''));
+});
+
+exports.sortBlacklistEntries = sortBlacklistEntries;