poi-plugin-kai-planner 1.0.0

package/src/storage/userPlans/fileStore.js

@@ -0,0 +1,106 @@
+/* src/storage/userPlans/fileStore.js */
+
+function getNodeModule(name) {
+  try {
+    if (typeof window !== "undefined" && typeof window.require === "function") {
+      return window.require(name);
+    }
+  } catch {}
+
+  try {
+    // eslint-disable-next-line global-require
+    return require(name);
+  } catch {
+    return null;
+  }
+}
+
+const fs = getNodeModule("fs");
+const path = getNodeModule("path");
+
+function isAvailable() {
+  return !!(fs && path);
+}
+
+function getPluginRoot() {
+  if (!isAvailable()) return null;
+  // current file: src/storage/userPlans/fileStore.js
+  return path.resolve(__dirname, "../../../");
+}
+
+function getStoreDir() {
+  const root = getPluginRoot();
+  if (!root) return null;
+  return path.join(root, "runtime_data", "userPlans");
+}
+
+function getStoreFilePath() {
+  const dir = getStoreDir();
+  if (!dir) return null;
+  return path.join(dir, "plans.v1.json");
+}
+
+function ensureStoreDir() {
+  if (!isAvailable()) return false;
+  const dir = getStoreDir();
+  if (!dir) return false;
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function exists() {
+  if (!isAvailable()) return false;
+  const fp = getStoreFilePath();
+  if (!fp) return false;
+  try {
+    return fs.existsSync(fp);
+  } catch {
+    return false;
+  }
+}
+
+function readRaw() {
+  if (!isAvailable()) return null;
+  const fp = getStoreFilePath();
+  if (!fp || !exists()) return null;
+  try {
+    const s = fs.readFileSync(fp, "utf8");
+    if (!s) return null;
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+function writeRaw(payload) {
+  if (!isAvailable()) return false;
+  if (!ensureStoreDir()) return false;
+
+  const fp = getStoreFilePath();
+  if (!fp) return false;
+  const tmp = `${fp}.tmp`;
+
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
+    fs.renameSync(tmp, fp);
+    return true;
+  } catch {
+    try {
+      if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    } catch {}
+    return false;
+  }
+}
+
+module.exports = {
+  isAvailable,
+  getStoreDir,
+  getStoreFilePath,
+  exists,
+  readRaw,
+  writeRaw,
+};

package/src/storage/userPlans/localStorageStore.js

@@ -0,0 +1,50 @@
+/* src/storage/userPlans/localStorageStore.js */
+
+const STORAGE_KEY = "kai_planner_user_plans_v1";
+
+function canUseLocalStorage() {
+  try {
+    return typeof window !== "undefined" && window.localStorage != null;
+  } catch {
+    return false;
+  }
+}
+
+function readRaw() {
+  if (!canUseLocalStorage()) return null;
+  try {
+    const s = window.localStorage.getItem(STORAGE_KEY);
+    if (!s) return null;
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+
+function writeRaw(payload) {
+  if (!canUseLocalStorage()) return false;
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(payload));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function clear() {
+  if (!canUseLocalStorage()) return false;
+  try {
+    window.localStorage.removeItem(STORAGE_KEY);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  STORAGE_KEY,
+  canUseLocalStorage,
+  readRaw,
+  writeRaw,
+  clear,
+};

package/src/storage/userPlans/migrate.js

@@ -0,0 +1,60 @@
+/* src/storage/userPlans/migrate.js */
+
+const CURRENT_VERSION = 1;
+
+function asArray(x) {
+  return Array.isArray(x) ? x : [];
+}
+
+function normalizePlanV1(plan) {
+  if (!plan || typeof plan !== "object") return null;
+  const id = plan.id == null ? null : String(plan.id);
+  if (!id) return null;
+  const snapshot = plan.startSnapshot && typeof plan.startSnapshot === "object" ? plan.startSnapshot : null;
+
+  return {
+    id,
+    createdAt: plan.createdAt || new Date().toISOString(),
+    updatedAt: plan.updatedAt || new Date().toISOString(),
+    note: plan.note == null ? "" : String(plan.note),
+    startApiId: plan.startApiId == null ? "" : String(plan.startApiId),
+    targetEquipId: plan.targetEquipId == null ? "" : String(plan.targetEquipId),
+    targetLevel: plan.targetLevel == null ? "0" : String(plan.targetLevel),
+    priority: plan.priority == null ? "P0" : String(plan.priority),
+    startSnapshot: snapshot
+      ? {
+          equipId: snapshot.equipId == null ? "" : String(snapshot.equipId),
+          level: snapshot.level == null ? "0" : String(snapshot.level),
+          name: snapshot.name == null ? "" : String(snapshot.name),
+        }
+      : null,
+    snapshotSteps: asArray(plan.snapshotSteps),
+    lastComputedAt: plan.lastComputedAt || null,
+    lastResult: plan.lastResult || null,
+  };
+}
+
+function migrateStore(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  const version = Number(obj.version) || 0;
+  let plans = [];
+
+  if (version <= 0) {
+    plans = asArray(obj.plans).map(normalizePlanV1).filter(Boolean);
+    return { version: CURRENT_VERSION, plans };
+  }
+
+  if (version === 1) {
+    plans = asArray(obj.plans).map(normalizePlanV1).filter(Boolean);
+    return { version: CURRENT_VERSION, plans };
+  }
+
+  // Forward-compat fallback: keep recognizable records.
+  plans = asArray(obj.plans).map(normalizePlanV1).filter(Boolean);
+  return { version: CURRENT_VERSION, plans };
+}
+
+module.exports = {
+  CURRENT_VERSION,
+  migrateStore,
+};

package/src/storage/userPlans/planStore.js

@@ -0,0 +1,107 @@
+/* src/storage/userPlans/planStore.js */
+
+const { CURRENT_VERSION } = require("./migrate");
+const { readStore, writeStore, getStorageInfo } = require("./storeAdapter");
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function loadPlans() {
+  return readStore().plans || [];
+}
+
+function savePlans(plans) {
+  writeStore({ version: CURRENT_VERSION, plans: Array.isArray(plans) ? plans : [] });
+}
+
+function makePlanId() {
+  return `plan_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function createPlan({ startApiId, targetEquipId, targetLevel, priority, note, startSnapshot, snapshotSteps }) {
+  const store = readStore();
+  const plan = {
+    id: makePlanId(),
+    createdAt: nowIso(),
+    updatedAt: nowIso(),
+    note: note == null ? "" : String(note),
+    startApiId: startApiId == null ? "" : String(startApiId),
+    targetEquipId: targetEquipId == null ? "" : String(targetEquipId),
+    targetLevel: targetLevel == null ? "0" : String(targetLevel),
+    priority: priority == null ? "P0" : String(priority),
+    startSnapshot:
+      startSnapshot && typeof startSnapshot === "object"
+        ? {
+            equipId: startSnapshot.equipId == null ? "" : String(startSnapshot.equipId),
+            level: startSnapshot.level == null ? "0" : String(startSnapshot.level),
+            name: startSnapshot.name == null ? "" : String(startSnapshot.name),
+          }
+        : null,
+    snapshotSteps: Array.isArray(snapshotSteps) ? snapshotSteps : [],
+    lastComputedAt: null,
+    lastResult: null,
+  };
+  store.plans.unshift(plan);
+  writeStore(store);
+  return plan;
+}
+
+function updatePlan(planId, patch) {
+  const store = readStore();
+  const idx = store.plans.findIndex((p) => String(p.id) === String(planId));
+  if (idx < 0) return null;
+  store.plans[idx] = {
+    ...store.plans[idx],
+    ...patch,
+    updatedAt: nowIso(),
+  };
+  writeStore(store);
+  return store.plans[idx];
+}
+
+function deletePlan(planId) {
+  const store = readStore();
+  const before = store.plans.length;
+  store.plans = store.plans.filter((p) => String(p.id) !== String(planId));
+  writeStore(store);
+  return store.plans.length !== before;
+}
+
+function replacePlanStartApiId(planId, newApiId) {
+  return updatePlan(planId, { startApiId: String(newApiId || "") });
+}
+
+function updatePlanPriority(planId, priority) {
+  return updatePlan(planId, { priority: String(priority == null ? "P0" : priority) });
+}
+
+function updatePlanTargetLevel(planId, targetLevel, snapshotSteps) {
+  const patch = {
+    targetLevel: String(targetLevel == null ? "0" : targetLevel),
+    lastResult: null,
+    lastComputedAt: null,
+  };
+  if (Array.isArray(snapshotSteps)) patch.snapshotSteps = snapshotSteps;
+  return updatePlan(planId, patch);
+}
+
+function upsertLastResult(planId, result) {
+  return updatePlan(planId, {
+    lastResult: result || null,
+    lastComputedAt: nowIso(),
+  });
+}
+
+module.exports = {
+  loadPlans,
+  savePlans,
+  createPlan,
+  updatePlan,
+  deletePlan,
+  replacePlanStartApiId,
+  updatePlanPriority,
+  updatePlanTargetLevel,
+  upsertLastResult,
+  getStorageInfo,
+};

package/src/storage/userPlans/storeAdapter.js

@@ -0,0 +1,77 @@
+/* src/storage/userPlans/storeAdapter.js */
+
+const { CURRENT_VERSION, migrateStore } = require("./migrate");
+const localStorageStore = require("./localStorageStore");
+const fileStore = require("./fileStore");
+
+function emptyStore() {
+  return { version: CURRENT_VERSION, plans: [] };
+}
+
+let initialized = false;
+
+function readFromPreferredBackend() {
+  if (fileStore.isAvailable()) {
+    return fileStore.readRaw();
+  }
+  return localStorageStore.readRaw();
+}
+
+function writeToPreferredBackend(payload) {
+  if (fileStore.isAvailable()) {
+    return fileStore.writeRaw(payload);
+  }
+  return localStorageStore.writeRaw(payload);
+}
+
+function initMigrationIfNeeded() {
+  if (initialized) return;
+  initialized = true;
+
+  // one-time migration: localStorage -> fileStore
+  if (!fileStore.isAvailable()) return;
+  if (fileStore.exists()) return;
+
+  const oldRaw = localStorageStore.readRaw();
+  if (!oldRaw) return;
+
+  const migrated = migrateStore(oldRaw || emptyStore());
+  const ok = fileStore.writeRaw(migrated);
+  if (ok) {
+    localStorageStore.clear();
+  }
+}
+
+function readStore() {
+  initMigrationIfNeeded();
+  const raw = readFromPreferredBackend();
+  const migrated = migrateStore(raw || emptyStore());
+  writeToPreferredBackend(migrated);
+  return migrated;
+}
+
+function writeStore(store) {
+  initMigrationIfNeeded();
+  const payload = migrateStore(store || emptyStore());
+  writeToPreferredBackend(payload);
+  return payload;
+}
+
+function getStorageInfo() {
+  if (fileStore.isAvailable()) {
+    return {
+      backend: "file",
+      path: fileStore.getStoreFilePath(),
+    };
+  }
+  return {
+    backend: "localStorage",
+    key: localStorageStore.STORAGE_KEY,
+  };
+}
+
+module.exports = {
+  readStore,
+  writeStore,
+  getStorageInfo,
+};