poi-plugin-remodel-assistant 1.2.3 → 1.2.4

package/views/app/plugin-bootstrap-area.js

@@ -5,14 +5,34 @@ exports.PluginBootstrapArea = void 0;
 
 var _react = _interopRequireWildcard(require("react"));
 
+var _reactBootstrap = require("react-bootstrap");
+
 var _itemInfoArea = require("./item-info-area");
 
 var _dataPackageDomain = require("../shared/domain/data-package-domain");
 
 var _runtimeDataPackage = require("../shared/runtime-data-package");
 
+var _pluginStateMigration = require("../shared/plugin-state-migration");
+
+var _pluginStateStorage = require("../shared/plugin-state-storage");
+
+var _pluginMaintenance = require("../shared/plugin-maintenance");
+
+var _derivedCacheResource = require("../shared/derived-cache-resource");
+
+var _pluginMigrationLock = require("../shared/plugin-migration-lock");
+
+var _pluginMeta = require("../shared/plugin-meta");
+
 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; } }
 
+const {
+  __: translate
+} = window.i18n[_pluginMeta.PLUGIN_ID];
+
+const __ = (key, ...args) => translate(`bootstrap.${key}`, ...args);
+
 class PluginBootstrapArea extends _react.Component {
   constructor(...args) {
     var _temp;
@@ -22,47 +42,272 @@ class PluginBootstrapArea extends _react.Component {
       enumerable: true,
       writable: true,
       value: {
-        runtimeDataRevision: (0, _dataPackageDomain.getDataPackageRevision)()
+        phase: 'starting',
+        ready: false,
+        closeConfirmStage: 0,
+        error: null,
+        runtimeDataRevision: 0,
+        pluginStateRevision: 0
+      }
+    }), Object.defineProperty(this, "showMigrationScreen", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => new Promise(resolve => {
+        if (!this.migrationCloseGuard) {
+          this.migrationCloseGuard = (0, _pluginMigrationLock.installPluginMigrationCloseGuard)({
+            hostWindow: window,
+            onCloseAttempt: () => {
+              if (!this.mounted || this.state.phase !== 'migrating') return;
+              this.setState(previous => ({
+                closeConfirmStage: previous.closeConfirmStage > 0 ? previous.closeConfirmStage : 1
+              }));
+            }
+          });
+        }
+
+        this.setState({
+          phase: 'migrating',
+          closeConfirmStage: 0
+        }, () => {
+          const scheduleFrame = typeof window.requestAnimationFrame === 'function' ? window.requestAnimationFrame.bind(window) : callback => setTimeout(callback, 0);
+          scheduleFrame(() => setTimeout(resolve, 0));
+        });
+      })
+    }), Object.defineProperty(this, "finishMigrationScreen", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => {
+        if (this.migrationCloseGuard) this.migrationCloseGuard.dispose();
+        this.migrationCloseGuard = null;
+        if (this.mounted) this.setState({
+          closeConfirmStage: 0
+        });
+      }
+    }), Object.defineProperty(this, "handleContinueMigration", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => this.setState({
+        closeConfirmStage: 0
+      })
+    }), Object.defineProperty(this, "handleEscalateMigrationClose", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => this.setState({
+        closeConfirmStage: 2
+      })
+    }), Object.defineProperty(this, "handleConfirmMigrationClose", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => {
+        if (this.migrationCloseGuard) this.migrationCloseGuard.forceClose();
+      }
+    }), Object.defineProperty(this, "handleRecoverLegacyState", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: async () => {
+        try {
+          await this.showMigrationScreen();
+          (0, _derivedCacheResource.releaseDerivedPluginRuntimeMemory)();
+          (0, _pluginStateMigration.recoverPluginStateFromLegacyConfig)(window.config);
+          if (!this.mounted) return;
+          this.setState({
+            ready: false,
+            error: null
+          }, () => {
+            this.bootstrap({
+              migrationScreenActive: true
+            });
+          });
+        } catch (error) {
+          this.finishMigrationScreen();
+          if (this.mounted) this.setState({
+            phase: 'error',
+            error
+          });
+        }
+      }
+    }), Object.defineProperty(this, "startRuntimeUpdater", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: () => {
+        if (!this.mounted || this.runtimeDataUpdateTimer) return;
+        (0, _runtimeDataPackage.ensureRuntimeDataPackageUpdated)().catch(() => null);
+        this.runtimeDataUpdateTimer = setInterval(() => {
+          (0, _runtimeDataPackage.ensureRuntimeDataPackageUpdated)().catch(() => null);
+        }, _runtimeDataPackage.RUNTIME_DATA_CHECK_INTERVAL_MS);
+      }
+    }), Object.defineProperty(this, "bootstrap", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: async ({
+        migrationScreenActive: existingMigrationScreen = false
+      } = {}) => {
+        let migrationScreenActive = Boolean(existingMigrationScreen);
+
+        try {
+          if (!migrationScreenActive && (0, _pluginStateMigration.isPluginStateMigrationRequired)()) {
+            migrationScreenActive = true;
+            await this.showMigrationScreen();
+            (0, _derivedCacheResource.releaseDerivedPluginRuntimeMemory)();
+          }
+
+          (0, _pluginStateMigration.bootstrapPluginState)(window.config);
+          await (0, _runtimeDataPackage.resolveRuntimeDataPackageSnapshot)();
+          const maintenance = await (0, _pluginMaintenance.runPendingPluginMaintenance)();
+          if (!this.mounted) return;
+          this.unsubscribeRuntimeData = (0, _dataPackageDomain.subscribeDataPackage)(snapshot => {
+            if (!this.mounted) return;
+            this.setState({
+              runtimeDataRevision: snapshot.revision
+            });
+          });
+          this.unsubscribePluginState = (0, _pluginStateStorage.subscribePluginState)(snapshot => {
+            if (!this.mounted) return;
+            this.setState({
+              pluginStateRevision: Number(snapshot.revision) || 0
+            });
+          });
+          const state = (0, _pluginStateStorage.getPluginStateSnapshot)();
+          if (migrationScreenActive) this.finishMigrationScreen();
+          this.setState({
+            phase: 'ready',
+            ready: true,
+            error: null,
+            runtimeDataRevision: (0, _dataPackageDomain.getDataPackageRevision)(),
+            pluginStateRevision: Number(state.revision) || 0
+          }, () => {
+            if (maintenance.finalized) this.startRuntimeUpdater();
+          });
+        } catch (error) {
+          if (migrationScreenActive) this.finishMigrationScreen();
+          if (!this.mounted) return;
+          this.setState({
+            phase: 'error',
+            error
+          });
+        }
       }
     }), _temp;
   }
 
   componentDidMount() {
     this.mounted = true;
-    this.unsubscribeRuntimeData = (0, _dataPackageDomain.subscribeDataPackage)(snapshot => {
-      if (!this.mounted) return;
-      this.setState({
-        runtimeDataRevision: snapshot.revision
-      });
-    });
-    const currentRevision = (0, _dataPackageDomain.getDataPackageRevision)();
-
-    if (currentRevision !== this.state.runtimeDataRevision) {
-      this.setState({
-        runtimeDataRevision: currentRevision
-      });
-    }
-
-    (0, _runtimeDataPackage.ensureRuntimeDataPackageUpdated)().catch(() => null);
-    this.runtimeDataUpdateTimer = setInterval(() => {
-      (0, _runtimeDataPackage.ensureRuntimeDataPackageUpdated)().catch(() => null);
-    }, _runtimeDataPackage.RUNTIME_DATA_CHECK_INTERVAL_MS);
+    this.bootstrap();
   }
 
   componentWillUnmount() {
     this.mounted = false;
     if (this.unsubscribeRuntimeData) this.unsubscribeRuntimeData();
     this.unsubscribeRuntimeData = null;
+    if (this.unsubscribePluginState) this.unsubscribePluginState();
+    this.unsubscribePluginState = null;
     if (this.runtimeDataUpdateTimer) clearInterval(this.runtimeDataUpdateTimer);
     this.runtimeDataUpdateTimer = null;
+    if (this.migrationCloseGuard) this.migrationCloseGuard.dispose();
+    this.migrationCloseGuard = null;
   }
 
   render() {
     const {
-      runtimeDataRevision
+      phase,
+      ready,
+      error,
+      runtimeDataRevision,
+      pluginStateRevision,
+      closeConfirmStage
     } = this.state;
+
+    if (phase === 'migrating') {
+      return _react.default.createElement("div", {
+        className: "plugin-data-migration-screen",
+        style: {
+          minHeight: 320,
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          padding: 32,
+          textAlign: 'center'
+        }
+      }, _react.default.createElement("div", {
+        style: {
+          width: 'min(720px, 92vw)'
+        }
+      }, _react.default.createElement("h1", {
+        style: {
+          fontSize: 30,
+          marginBottom: 18
+        }
+      }, __('Updating plugin data')), _react.default.createElement("p", {
+        style: {
+          fontSize: 18,
+          lineHeight: 1.7
+        }
+      }, __('Plans and equipment assignments are being migrated and verified.')), _react.default.createElement("p", {
+        style: {
+          fontSize: 18,
+          fontWeight: 600,
+          lineHeight: 1.7
+        }
+      }, __('Please do not close Poi, disable, or restart the plugin until this finishes.')), _react.default.createElement("p", null, __('The plugin will continue automatically after the new data is reloaded successfully.')), closeConfirmStage === 1 && _react.default.createElement("div", {
+        style: {
+          marginTop: 28
+        }
+      }, _react.default.createElement("p", null, __('Data update is still running. Continue waiting is recommended.')), _react.default.createElement("div", {
+        style: {
+          display: 'flex',
+          justifyContent: 'space-between',
+          gap: 24
+        }
+      }, _react.default.createElement(_reactBootstrap.Button, {
+        bsStyle: "danger",
+        onClick: this.handleEscalateMigrationClose
+      }, __('Close anyway')), _react.default.createElement(_reactBootstrap.Button, {
+        bsStyle: "primary",
+        autoFocus: true,
+        onClick: this.handleContinueMigration
+      }, __('Continue waiting')))), closeConfirmStage === 2 && _react.default.createElement("div", {
+        style: {
+          marginTop: 28
+        }
+      }, _react.default.createElement("p", null, __('Confirm interrupting the data update?')), _react.default.createElement("div", {
+        style: {
+          display: 'flex',
+          justifyContent: 'space-between',
+          gap: 24
+        }
+      }, _react.default.createElement(_reactBootstrap.Button, {
+        bsStyle: "primary",
+        autoFocus: true,
+        onClick: this.handleContinueMigration
+      }, __('Return and wait')), _react.default.createElement(_reactBootstrap.Button, {
+        bsStyle: "danger",
+        onClick: this.handleConfirmMigrationClose
+      }, __('Confirm close Poi'))))));
+    }
+
+    if (error) {
+      const recoveryRequired = String(error && error.message || '') === 'plugin-state-recovery-required';
+      return _react.default.createElement("div", {
+        className: "plugin-bootstrap-error"
+      }, _react.default.createElement("div", null, String(error && error.message || error)), recoveryRequired ? _react.default.createElement("div", {
+        className: "plugin-bootstrap-recovery"
+      }, _react.default.createElement("p", null, __('Plugin State is damaged. Automatic legacy fallback is disabled to protect newer plans.')), _react.default.createElement("p", null, __('Restore migration-time configuration only if you accept losing changes made after migration.')), _react.default.createElement(_reactBootstrap.Button, {
+        onClick: this.handleRecoverLegacyState
+      }, __('Restore migration-time configuration'))) : null);
+    }
+
+    if (!ready) return null;
     return _react.default.createElement(_itemInfoArea.ItemInfoArea, {
-      runtimeDataRevision: runtimeDataRevision
+      runtimeDataRevision: runtimeDataRevision,
+      pluginStateRevision: pluginStateRevision
     });
   }
 

package/views/new-interface/app/decision-snapshot-cache.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.SNAPSHOT_INPUT_KEYS = exports.FOUNDATION_INPUT_KEYS = exports.createDecisionFoundationCache = exports.readDecisionFoundationCache = exports.clearProcessDecisionSnapshotCache = exports.writeProcessDecisionSnapshotCache = exports.readProcessDecisionSnapshotCache = exports.createDecisionSnapshotCache = exports.readDecisionSnapshotCache = exports.sameDecisionSnapshotInputs = void 0;
+exports.SNAPSHOT_INPUT_KEYS = exports.SNAPSHOT_FEEDBACK_CONTEXT_KEYS = exports.clearProcessDecisionSnapshotCache = exports.writeProcessDecisionSnapshotCache = exports.readProcessDecisionSnapshotCache = exports.createDecisionSnapshotCache = exports.readDecisionSnapshotCache = exports.sameDecisionSnapshotFeedbackContext = exports.sameDecisionSnapshotInputs = void 0;
 
 var _pluginMeta = require("../../shared/plugin-meta");
 
@@ -9,12 +9,12 @@ var _equipmentBlacklistDomain = require("../equipment/domain/equipment-blacklist
 
 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 SNAPSHOT_INPUT_KEYS = ['dataRevision', 'dataIdentity', 'plans', 'initialDay', 'masterEquips', 'actualEquipLevels', 'actualEquipInventory', 'actualOwnedShipMasterIds', 'decisionSelections', 'planRouteSelections', 'currentInventoryBindings', 'equipmentBlacklist', 'routeAcquisitionIndex'];
+const SNAPSHOT_INPUT_KEYS = ['dataRevision', 'dataIdentity', 'plans', 'initialDay', 'masterEquips', 'masterUseitems', 'equipTypes', 'staticItems', 'actualEquipLevels', 'actualEquipInventory', 'actualUseitems', 'actualResourceBudget', 'equipmentRealityReady', 'actualOwnedShipMasterIds', 'decisionSelections', 'planRouteSelections', 'currentInventoryBindings', 'equipmentBlacklist', 'routeAcquisitionIndex'];
 exports.SNAPSHOT_INPUT_KEYS = SNAPSHOT_INPUT_KEYS;
-const FOUNDATION_INPUT_KEYS = ['dataRevision', 'masterEquips'];
-exports.FOUNDATION_INPUT_KEYS = FOUNDATION_INPUT_KEYS;
+const SNAPSHOT_FEEDBACK_CONTEXT_KEYS = SNAPSHOT_INPUT_KEYS.filter(key => key !== 'currentInventoryBindings');
+exports.SNAPSHOT_FEEDBACK_CONTEXT_KEYS = SNAPSHOT_FEEDBACK_CONTEXT_KEYS;
 const HOST_SESSION_SNAPSHOT_CACHE_KEY = Symbol.for('poi-plugin-remodel-assistant.decision-snapshot-session-cache');
-const HOST_SESSION_SNAPSHOT_CACHE_SCHEMA = 1;
+const HOST_SESSION_SNAPSHOT_CACHE_SCHEMA = 6;
 let processDecisionSnapshotCache = null;
 
 const hostSession = () => typeof globalThis === 'undefined' ? null : globalThis;
@@ -56,9 +56,14 @@ const stableValue = value => {
   return result;
 };
 
-const stableSignature = value => JSON.stringify(stableValue(value || {}));
+const stableSignature = value => JSON.stringify(stableValue(value || {})); // `masterEquips` is intentionally excluded from semantic deep hashing. It is a
+// large static host/runtime projection whose lifecycle is already represented by
+// `dataRevision` / `dataIdentity`; hashing the whole master map on every cache hit
+// turns a page switch into O(master-data-size) work. Reference comparison is the
+// cheap secondary guard for unexpected replacement under the same data identity.
 
-const CONTENT_IDENTITY_KEYS = new Set(['plans', 'actualEquipLevels', 'actualEquipInventory', 'actualOwnedShipMasterIds', 'decisionSelections', 'planRouteSelections', 'currentInventoryBindings', 'routeAcquisitionIndex']);
+
+const CONTENT_IDENTITY_KEYS = new Set(['plans', 'actualEquipLevels', 'actualEquipInventory', 'actualUseitems', 'actualResourceBudget', 'actualOwnedShipMasterIds', 'decisionSelections', 'planRouteSelections', 'currentInventoryBindings', 'routeAcquisitionIndex']);
 
 const inputIdentity = (key, value) => {
   if (key === 'equipmentBlacklist') return (0, _equipmentBlacklistDomain.equipmentBlacklistSignature)(value);
@@ -66,7 +71,19 @@ const inputIdentity = (key, value) => {
   return value;
 };
 
-const inputIdentities = (inputs, keys) => Object.fromEntries(keys.map(key => [key, inputIdentity(key, inputs[key])]));
+const inputIdentities = (inputs, keys) => Object.fromEntries(keys.map(key => [key, inputIdentity(key, inputs[key])])); // The feedback fuse is evaluated only when a Snapshot proposes a binding
+// transition, so it can afford semantic comparison for the large master map.
+// Do not reuse the hot-path cache identity here: equal master data reconstructed
+// into a fresh object is still the same Decision context and must not reset the
+// assignment-transition history.
+
+
+const feedbackContextIdentity = (key, value) => key === 'masterEquips' ? stableSignature(value) : inputIdentity(key, value);
+
+const sameFeedbackContextInputs = (left, right, keys) => {
+  if (!left || !right) return false;
+  return keys.every(key => feedbackContextIdentity(key, left[key]) === feedbackContextIdentity(key, right[key]));
+};
 
 const sameInputs = (left, right, keys) => {
   if (!left || !right) return false;
@@ -84,10 +101,18 @@ const createCache = (inputs, value, keys = SNAPSHOT_INPUT_KEYS) => _extends({},
   value
 });
 
-const sameDecisionSnapshotInputs = (left, right) => sameInputs(left, right, SNAPSHOT_INPUT_KEYS);
+const sameDecisionSnapshotInputs = (left, right) => sameInputs(left, right, SNAPSHOT_INPUT_KEYS); // Binding State is both a Decision input and an explicit publish result. The
+// Allocation algorithm never feeds that result back into the same round; this
+// comparison exists only so the safety fuse can distinguish a legitimate later
+// Snapshot from an accidental binding-only renderer loop.
+
 
 exports.sameDecisionSnapshotInputs = sameDecisionSnapshotInputs;
 
+const sameDecisionSnapshotFeedbackContext = (left, right) => sameFeedbackContextInputs(left, right, SNAPSHOT_FEEDBACK_CONTEXT_KEYS);
+
+exports.sameDecisionSnapshotFeedbackContext = sameDecisionSnapshotFeedbackContext;
+
 const readDecisionSnapshotCache = (cache, inputs) => _pluginMeta.FORCE_FULL_DECISION_REBUILD ? null : readCache(cache, inputs, SNAPSHOT_INPUT_KEYS);
 
 exports.readDecisionSnapshotCache = readDecisionSnapshotCache;
@@ -125,12 +150,4 @@ const clearProcessDecisionSnapshotCache = () => {
   clearHostSessionDecisionSnapshotCache();
 };
 
-exports.clearProcessDecisionSnapshotCache = clearProcessDecisionSnapshotCache;
-
-const readDecisionFoundationCache = (cache, inputs) => _pluginMeta.FORCE_FULL_DECISION_REBUILD ? null : readCache(cache, inputs, FOUNDATION_INPUT_KEYS);
-
-exports.readDecisionFoundationCache = readDecisionFoundationCache;
-
-const createDecisionFoundationCache = (inputs, value) => createCache(inputs, value, FOUNDATION_INPUT_KEYS);
-
-exports.createDecisionFoundationCache = createDecisionFoundationCache;
+exports.clearProcessDecisionSnapshotCache = clearProcessDecisionSnapshotCache;