poi-plugin-compass 0.1.0

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "poi-plugin-compass",
+  "version": "0.1.0",
+  "description": "通常海域舰队罗盘",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RikaKagurasaka/poi-plugin-compass.git"
+  },
+  "bugs": {
+    "url": "https://github.com/RikaKagurasaka/poi-plugin-compass/issues"
+  },
+  "homepage": "https://github.com/RikaKagurasaka/poi-plugin-compass#readme",
+  "files": [
+    "index.js",
+    "logic.js",
+    "enemies.js",
+    "exporters.js",
+    "overview.js",
+    "air-status.js",
+    "data",
+    "assets",
+    "scripts",
+    "README.md",
+    "docs"
+  ],
+  "scripts": {
+    "cache:kcwiki": "node scripts/cache-kcwiki-routes.js",
+    "cache:kcnav-maps": "node scripts/cache-kcnav-maps.js",
+    "cache:kcnav-enemies": "node scripts/cache-kcnav-enemies.js",
+    "compress:kcnav-maps": "node scripts/compress-kcnav-maps.js --remove-png",
+    "compress:kcnav-enemies": "node scripts/compact-kcnav-enemies.js",
+    "check:syntax": "node --check index.js && node --check logic.js && node --check enemies.js && node --check exporters.js && node --check scripts/cache-kcnav-enemies.js && node --check scripts/compress-kcnav-maps.js && node --check scripts/compact-kcnav-enemies.js && node --check test.js && node --check test-enemies.js && node --check test-exporters.js",
+    "test": "node test.js && node test-enemies.js && node test-exporters.js && node test-ui.js && node test-overview.js"
+  },
+  "keywords": [
+    "poi-plugin",
+    "kancolle",
+    "compass",
+    "routing"
+  ],
+  "author": {
+    "name": "Rika",
+    "url": "https://github.com/RikaKagurasaka"
+  },
+  "license": "MIT",
+  "poiPlugin": {
+    "id": "compass",
+    "title": "舰队罗盘",
+    "description": "通常海域地图、带路条件和路线概率",
+    "icon": "fa/compass",
+    "priority": 20,
+    "apiVer": {
+      "11.99.99": "0.1.0"
+    }
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "lzma": "2.3.2"
+  }
+}

package/scripts/cache-kcnav-enemies.js

@@ -0,0 +1,97 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const nodeTypes = require('../data/kcnav-node-types-by-map.json')
+const styles = require('../data/kcnav-node-types.json')
+const root = path.join(__dirname, '../data/sources/kcnav/enemies')
+
+function monthWindow(now = new Date()) {
+  const end = now.toISOString().slice(0, 10)
+  const startDate = new Date(`${end}T00:00:00Z`)
+  const day = startDate.getUTCDate()
+  startDate.setUTCDate(1)
+  startDate.setUTCMonth(startDate.getUTCMonth() - 1)
+  const lastDay = new Date(Date.UTC(startDate.getUTCFullYear(), startDate.getUTCMonth() + 1, 0)).getUTCDate()
+  startDate.setUTCDate(Math.min(day, lastDay))
+  return { start: startDate.toISOString().slice(0, 10), end }
+}
+
+function enemyUrl(mapId, node, window) {
+  const url = new URL(`https://tsunkit.net/api/routing/maps/${mapId}/nodes/${encodeURIComponent(node)}/enemycomps`)
+  url.searchParams.set('start', window.start)
+  url.searchParams.set('end', window.end)
+  return url.toString()
+}
+
+function validateResponse(payload) {
+  const result = payload?.result
+  if (!result || !Array.isArray(result.entries)
+    || (result.entryCount != null && result.entryCount !== result.entries.length)) {
+    throw new Error('Invalid or incomplete enemy response')
+  }
+  for (const entry of result.entries) {
+    if (!Array.isArray(entry.mainFleet) || !Array.isArray(entry.escortFleet)
+      || !Number.isFinite(entry.count) || entry.count < 0
+      || [...entry.mainFleet, ...entry.escortFleet].some((ship) => !Number.isInteger(ship.id))) {
+      throw new Error('Invalid enemy composition')
+    }
+  }
+  return result
+}
+
+function writeJson(file, value, compact = false) {
+  const content = `${JSON.stringify(value, null, compact ? 0 : 2)}\n`
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(`${file}.tmp`, content)
+  fs.renameSync(`${file}.tmp`, file)
+  return crypto.createHash('sha256').update(content).digest('hex')
+}
+
+async function main() {
+  const manifestPath = path.join(root, 'manifest.json')
+  const previous = fs.existsSync(manifestPath) ? JSON.parse(fs.readFileSync(manifestPath, 'utf8')) : null
+  // Resume the same window even across midnight; --refresh explicitly starts a new run.
+  const window = previous && !previous.complete && !process.argv.includes('--refresh')
+    ? previous.window : monthWindow()
+  const sameWindow = previous && previous.window.start === window.start && previous.window.end === window.end
+  const manifest = sameWindow && !process.argv.includes('--refresh') ? previous : {
+    source: 'KCNav', window, intervalMs: 15000, complete: false, nodes: {},
+  }
+  const targets = Object.entries(nodeTypes).sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
+    .flatMap(([mapId, nodes]) => Object.entries(nodes)
+      .filter(([, type]) => styles[type]?.hasEnemies)
+      .map(([node]) => ({ mapId, node })))
+  manifest.targetCount = targets.length
+  writeJson(manifestPath, manifest)
+  for (const [index, { mapId, node }] of targets.entries()) {
+    const key = `${mapId}/${node}`
+    const saved = manifest.nodes[key]
+    if (saved && fs.existsSync(path.join(root, saved.file))) {
+      const hash = crypto.createHash('sha256').update(fs.readFileSync(path.join(root, saved.file))).digest('hex')
+      if (hash === saved.sha256) continue
+    }
+    const wait = Math.max(0, 15000 - (Date.now() - Date.parse(manifest.lastRequestAt || '1970-01-01')))
+    if (wait) await new Promise((resolve) => setTimeout(resolve, wait))
+    manifest.lastRequestAt = new Date().toISOString()
+    manifest.complete = false
+    writeJson(manifestPath, manifest)
+    const url = enemyUrl(mapId, node, window)
+    console.log(`${index + 1}/${targets.length} ${key} ${window.start}..${window.end}`)
+    const response = await fetch(url, { signal: AbortSignal.timeout(60000) })
+    if (!response.ok) throw new Error(`${key}: HTTP ${response.status}; cache retained, rerun to resume`)
+    const payload = await response.json()
+    const result = validateResponse(payload)
+    const file = `${window.start}_${window.end}/${mapId}/${node}.json`
+    const sha256 = writeJson(path.join(root, file), payload, true)
+    manifest.nodes[key] = { file, url, sha256, fetchedAt: new Date().toISOString(), entries: result.entries.length }
+    writeJson(manifestPath, manifest)
+  }
+  manifest.complete = true
+  writeJson(manifestPath, manifest)
+  console.log(`Cached ${targets.length} enemy nodes`)
+}
+
+if (require.main === module) main().catch((error) => { console.error(error.message); process.exitCode = 1 })
+module.exports = { monthWindow, enemyUrl, validateResponse }

package/scripts/cache-kcnav-maps.js

@@ -0,0 +1,109 @@
+'use strict'
+
+const crypto = require('crypto')
+const fs = require('fs')
+const path = require('path')
+
+const root = path.resolve(__dirname, '..')
+const outputDir = path.join(root, 'data', 'sources', 'kcnav', 'maps')
+const nodeTypesPath = path.join(root, 'data', 'kcnav-node-types-by-map.json')
+const manifestPath = path.join(outputDir, 'manifest.json')
+const catalogs = [
+  require(path.join(root, 'data', 'maps.json')),
+  require(path.join(root, 'data', 'normal-maps.json')),
+]
+const mapIds = Array.from(new Set(catalogs.flatMap((catalog) => Object.keys(catalog.maps))))
+  .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }))
+
+const DEFAULT_INTERVAL_MS = 15_000
+
+function apiUrl(mapId) {
+  return `https://tsunkit.net/api/routing/maps/${mapId}/`
+}
+
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds))
+}
+
+function intervalFromArgs() {
+  const index = process.argv.indexOf('--interval-ms')
+  if (index < 0) return DEFAULT_INTERVAL_MS
+  const value = Number(process.argv[index + 1])
+  return Number.isFinite(value) && value >= 0 ? value : DEFAULT_INTERVAL_MS
+}
+
+function nodeTypesFromResult(result) {
+  const nodeValues = {}
+  const spots = result?.spots || {}
+  Object.keys(spots).forEach((node) => { nodeValues[node] = -1 })
+
+  Object.values(spots).forEach((spot) => {
+    if (!Array.isArray(spot) || typeof spot[2] !== 'string' || spot[2].toLowerCase() !== 'start') return
+    const node = Object.keys(spots).find((key) => spots[key] === spot)
+    if (node) nodeValues[node] = 0
+  })
+
+  Object.values(result?.route || {}).forEach((entry) => {
+    if (!Array.isArray(entry) || typeof entry[1] !== 'string') return
+    const nodeType = Number(entry[2])
+    if (Number.isFinite(nodeType)) nodeValues[entry[1]] = nodeType
+  })
+  return nodeValues
+}
+
+function writeJson(filePath, value) {
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+}
+
+async function fetchMap(mapId) {
+  const url = apiUrl(mapId)
+  const response = await fetch(url, {
+    headers: { 'user-agent': 'poi-plugin-compass-kcnav-cache/0.1' },
+  })
+  if (!response.ok) throw new Error(`KCNav API ${response.status} for ${mapId}`)
+  const payload = await response.json()
+  if (!payload?.result || typeof payload.result !== 'object') {
+    throw new Error(`KCNav response has no result for ${mapId}`)
+  }
+  return { url, payload }
+}
+
+async function main() {
+  const intervalMs = intervalFromArgs()
+  fs.mkdirSync(outputDir, { recursive: true })
+  const fetchedAt = new Date().toISOString()
+  const manifest = []
+  const nodeTypesByMap = {}
+
+  for (const [index, mapId] of mapIds.entries()) {
+    if (index > 0) await sleep(intervalMs)
+    process.stdout.write(`fetching ${mapId} (${index + 1}/${mapIds.length})\n`)
+    const { url, payload } = await fetchMap(mapId)
+    const content = `${JSON.stringify(payload, null, 2)}\n`
+    const contentFile = `${mapId}.json`
+    fs.writeFileSync(path.join(outputDir, contentFile), content, 'utf8')
+    nodeTypesByMap[mapId] = nodeTypesFromResult(payload.result)
+    manifest.push({
+      mapId,
+      apiUrl: url,
+      contentFile,
+      sha256: crypto.createHash('sha256').update(content, 'utf8').digest('hex'),
+      nodeCount: Object.keys(payload.result.spots || {}).length,
+      nodeTypeCount: Object.keys(nodeTypesByMap[mapId]).length,
+      fetchedAt,
+    })
+    writeJson(manifestPath, { source: 'tsunkit.net', fetchedAt, intervalMs, maps: manifest })
+    writeJson(nodeTypesPath, nodeTypesByMap)
+  }
+
+  console.log(`cached ${manifest.length} KCNav maps in ${outputDir}`)
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(error.message)
+    process.exitCode = 1
+  })
+}
+
+module.exports = { apiUrl, nodeTypesFromResult, main }

package/scripts/cache-kcwiki-routes.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const crypto = require('crypto')
+const fs = require('fs')
+const path = require('path')
+
+const areaNames = {
+  1: '镇守府海域',
+  2: '南西群岛海域',
+  3: '北方海域',
+  4: '西方海域',
+  5: '南方海域',
+  6: '中部海域',
+  7: '南西海域',
+}
+
+const root = path.resolve(__dirname, '..')
+const outputDir = path.join(root, 'data', 'sources', 'kcwiki', 'routes')
+const catalogs = [
+  require(path.join(root, 'data', 'maps.json')),
+  require(path.join(root, 'data', 'normal-maps.json')),
+]
+const mapIds = Array.from(new Set(catalogs.flatMap((catalog) => Object.keys(catalog.maps))))
+  .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }))
+
+function apiUrl(title) {
+  const url = new URL('https://zh.kcwiki.cn/api.php')
+  url.search = new URLSearchParams({
+    action: 'query',
+    format: 'json',
+    formatversion: '2',
+    prop: 'revisions',
+    rvprop: 'content|ids|timestamp',
+    titles: title,
+  }).toString()
+  return url
+}
+
+function pageTitleForMap(mapId) {
+  const [area] = mapId.split('-').map(Number)
+  return mapId === '5-6'
+    ? `${areaNames[area]}/${mapId}`
+    : `${areaNames[area]}/${mapId}/带路条件`
+}
+
+async function fetchPage(title) {
+  const response = await fetch(apiUrl(title), {
+    headers: { 'user-agent': 'poi-plugin-compass-kcwiki-cache/0.1' },
+  })
+  if (!response.ok) throw new Error(`KCWiki API ${response.status} for ${title}`)
+  const payload = await response.json()
+  const page = payload?.query?.pages?.[0]
+  if (!page || page.missing || !page.revisions?.[0]) throw new Error(`KCWiki page missing: ${title}`)
+  const revision = page.revisions[0]
+  const content = revision.content ?? revision.slots?.main?.content
+  if (typeof content !== 'string') throw new Error(`KCWiki content missing: ${title}`)
+  return { page, revision, content }
+}
+
+async function main() {
+  fs.mkdirSync(outputDir, { recursive: true })
+  const fetchedAt = new Date().toISOString()
+  const manifest = []
+
+  for (const mapId of mapIds) {
+    const title = pageTitleForMap(mapId)
+    const { page, revision, content } = await fetchPage(title)
+    const contentFile = `${mapId}.wiki`
+    fs.writeFileSync(path.join(outputDir, contentFile), content, 'utf8')
+    manifest.push({
+      mapId,
+      title,
+      pageId: page.pageid,
+      revisionId: revision.revid,
+      revisionTimestamp: revision.timestamp,
+      pageUrl: `https://zh.kcwiki.cn/wiki/${encodeURIComponent(title)}`,
+      apiUrl: apiUrl(title).toString(),
+      contentFile,
+      sha256: crypto.createHash('sha256').update(content, 'utf8').digest('hex'),
+      fetchedAt,
+    })
+    await new Promise((resolve) => setTimeout(resolve, 200))
+  }
+
+  fs.writeFileSync(
+    path.join(outputDir, 'manifest.json'),
+    `${JSON.stringify({ source: 'zh.kcwiki.cn', fetchedAt, maps: manifest }, null, 2)}\n`,
+    'utf8',
+  )
+  console.log(`cached ${manifest.length} KCWiki route pages in ${outputDir}`)
+}
+
+main().catch((error) => {
+  console.error(error.message)
+  process.exitCode = 1
+})

package/scripts/compact-kcnav-enemies.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const crypto = require('crypto')
+const fs = require('fs')
+const path = require('path')
+
+const root = path.join(__dirname, '../data/sources/kcnav/enemies')
+const manifestPath = path.join(root, 'manifest.json')
+
+function compactJson(value) {
+  return `${JSON.stringify(value)}\n`
+}
+
+function sha256(content) {
+  return crypto.createHash('sha256').update(content).digest('hex')
+}
+
+function main() {
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+  let beforeBytes = 0
+  let afterBytes = 0
+  let count = 0
+  for (const entry of Object.values(manifest.nodes || {})) {
+    const file = path.join(root, entry.file)
+    const value = JSON.parse(fs.readFileSync(file, 'utf8'))
+    const content = compactJson(value)
+    const temporary = `${file}.${process.pid}.tmp`
+    beforeBytes += fs.statSync(file).size
+    fs.writeFileSync(temporary, content)
+    fs.renameSync(temporary, file)
+    afterBytes += content.length
+    entry.sha256 = sha256(content)
+    count += 1
+  }
+  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+  console.log(JSON.stringify({
+    files: count,
+    beforeBytes,
+    afterBytes,
+    reductionPercent: Number(((1 - afterBytes / beforeBytes) * 100).toFixed(1)),
+  }, null, 2))
+}
+
+if (require.main === module) {
+  try {
+    main()
+  } catch (error) {
+    console.error(error.message)
+    process.exitCode = 1
+  }
+}
+
+module.exports = { compactJson, main }

package/scripts/compress-kcnav-maps.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { execFileSync } = require('child_process')
+
+const mapDir = path.join(__dirname, '../assets/kcnav/maps')
+
+function commandAvailable(command) {
+  try {
+    execFileSync(command, ['-version'], { stdio: 'ignore' })
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+function optionValue(name, fallback) {
+  const index = process.argv.indexOf(name)
+  if (index < 0) return fallback
+  const value = Number(process.argv[index + 1])
+  return Number.isFinite(value) && value >= 0 && value <= 100 ? value : fallback
+}
+
+function convert(input, output, quality, tool) {
+  const temporary = `${output}.${process.pid}.tmp`
+  try {
+    if (tool === 'cwebp') {
+      execFileSync('cwebp', [
+        '-quiet', '-mt', '-m', '4', '-q', String(quality), '-metadata', 'none', input, '-o', temporary,
+      ], { stdio: 'inherit' })
+    } else {
+      execFileSync('ffmpeg', [
+        '-y', '-loglevel', 'error', '-i', input, '-map_metadata', '-1',
+        '-c:v', 'libwebp', '-q:v', String(quality), '-compression_level', '4', temporary,
+      ], { stdio: 'inherit' })
+    }
+    fs.renameSync(temporary, output)
+  } finally {
+    if (fs.existsSync(temporary)) fs.unlinkSync(temporary)
+  }
+}
+
+function main() {
+  const quality = optionValue('--quality', 85)
+  const removePng = process.argv.includes('--remove-png')
+  const tool = commandAvailable('cwebp') ? 'cwebp' : commandAvailable('ffmpeg') ? 'ffmpeg' : null
+  if (!tool) throw new Error('需要 cwebp 或 ffmpeg 才能压缩 KCNav 地图')
+
+  const pngFiles = fs.readdirSync(mapDir).filter((file) => file.endsWith('.png')).sort()
+  if (!pngFiles.length) {
+    const webpFiles = fs.readdirSync(mapDir).filter((file) => file.endsWith('.webp')).sort()
+    console.log(`没有待转换的 PNG 地图；现有 WebP ${webpFiles.length} 张`)
+    return
+  }
+
+  let sourceBytes = 0
+  let outputBytes = 0
+  for (const file of pngFiles) {
+    const input = path.join(mapDir, file)
+    const output = path.join(mapDir, file.replace(/\.png$/, '.webp'))
+    convert(input, output, quality, tool)
+    sourceBytes += fs.statSync(input).size
+    outputBytes += fs.statSync(output).size
+    if (removePng) fs.unlinkSync(input)
+  }
+
+  console.log(JSON.stringify({
+    tool,
+    quality,
+    maps: pngFiles.length,
+    sourceBytes,
+    outputBytes,
+    reductionPercent: Number(((1 - outputBytes / sourceBytes) * 100).toFixed(1)),
+    removedPng: removePng,
+    tempDirectory: os.tmpdir(),
+  }, null, 2))
+}
+
+if (require.main === module) {
+  try {
+    main()
+  } catch (error) {
+    console.error(error.message)
+    process.exitCode = 1
+  }
+}
+
+module.exports = { main }