uomtiles 0.1.2 → 0.1.4

package/dist/src/cli.js

@@ -9,6 +9,7 @@ import { isSea } from 'node:sea';
 import { defineCommand, runMain } from 'citty';
 import { accountFile, uomtilesDataDir, workspaceDirectory } from "./core/paths.js";
 import { DEFAULT_GRID_CRAWL_OPTIONS, runGridCrawl } from "./grid-crawl.js";
+import { DEFAULT_DJI_CONCURRENCY, updateMapLayers } from "./map-layer-update.js";
 import { FETCH_PROCESS_ENV } from "./core/fetch-process.js";
 import { shellEnvironmentHint } from "./core/shell.js";
 import { diffUomtiles, exportTiles, inspectUomtiles, migrateToUomtiles } from "./core/uomtiles.js";
@@ -146,16 +147,22 @@ function openUrl(url) {
     child.unref();
 }
 function loadWebEnvironment() {
-    const environmentFile = resolve(process.cwd(), '.env');
-    if (existsSync(environmentFile))
-        loadEnvFile(environmentFile);
+    loadProjectEnvironment();
     if (process.env.NUXT_TIANDITU_TOKEN?.trim())
         return;
     const shell = shellEnvironmentHint(process.platform, process.env);
     console.warn('天地图令牌未配置，工作台将使用 OSM，天地图选项不可用。');
-    console.warn(`持久配置：在 ${environmentFile} 中添加 NUXT_TIANDITU_TOKEN=你的天地图令牌`);
+    console.warn(`持久配置：在 ${projectEnvironmentFile()} 中添加 NUXT_TIANDITU_TOKEN=你的天地图令牌`);
     console.warn(`当前 ${shell.name} 临时配置：${shell.command}`);
 }
+function projectEnvironmentFile() {
+    return resolve(process.cwd(), '.env');
+}
+function loadProjectEnvironment() {
+    const environmentFile = projectEnvironmentFile();
+    if (existsSync(environmentFile))
+        loadEnvFile(environmentFile);
+}
 async function web() {
     loadWebEnvironment();
     const entry = resolve(root, '.output/server/index.mjs');
@@ -251,6 +258,51 @@ const migrateCommand = defineCommand({
         console.log(JSON.stringify(migrateToUomtiles(args.input, args.output, account?.username || null), null, 2));
     },
 });
+const mapLayersUpdateCommand = defineCommand({
+    meta: { name: 'map-layers-update', description: '在线更新 DJI Flysafe 与 Antigravity 图层快照' },
+    args: () => {
+        loadProjectEnvironment();
+        return {
+            output: {
+                type: 'string',
+                description: '快照输出目录',
+                valueHint: 'PATH',
+                default: resolve(uomtilesDataDir(), 'map-layers'),
+            },
+            'dji-raw-dir': {
+                type: 'string',
+                description: '用于断点续传的 DJI 原始响应目录',
+                valueHint: 'PATH',
+                required: false,
+            },
+            'dji-concurrency': {
+                type: 'string',
+                description: 'DJI 并发请求数',
+                valueHint: 'N',
+                default: String(DEFAULT_DJI_CONCURRENCY),
+            },
+            'dji-resume': {
+                type: 'boolean',
+                description: '复用当前更新会话中已验证的 DJI 原始响应',
+                negativeDescription: '忽略当前 DJI 更新会话并重新下载',
+                default: true,
+            },
+        };
+    },
+    run: async ({ args }) => {
+        const djiConcurrency = Number(args['dji-concurrency']);
+        if (!Number.isInteger(djiConcurrency) || djiConcurrency <= 0) {
+            throw new Error('--dji-concurrency 必须是正整数');
+        }
+        const result = await updateMapLayers({
+            outputDirectory: args.output,
+            djiRawDirectory: args['dji-raw-dir'],
+            djiConcurrency,
+            djiResume: args['dji-resume'],
+        });
+        console.log(JSON.stringify(result, null, 2));
+    },
+});
 const mainCommand = defineCommand({
     meta: {
         name: 'uomtiles',
@@ -267,6 +319,12 @@ const mainCommand = defineCommand({
         export: exportCommand,
         diff: diffCommand,
         migrate: migrateCommand,
+        'map-layers-update': mapLayersUpdateCommand,
     },
 });
-await runMain(mainCommand);
+function cliArguments(arguments_) {
+    if (arguments_[0] !== 'map-layers-update')
+        return arguments_;
+    return arguments_.filter(argument => argument !== '--');
+}
+await runMain(mainCommand, { rawArgs: cliArguments(process.argv.slice(2)) });

package/dist/src/core/dji-snapshot.js

@@ -0,0 +1,135 @@
+import { createHash } from 'node:crypto';
+import { DJI_COVERAGE, DJI_ENDPOINT, DJI_LEVELS, DJI_MAX_SPLIT_DEPTH, DJI_OVERLAP_DEGREES, DJI_ROW_DEGREES, DJI_SATURATION_LIMIT, DJI_TARGET_DIAGONAL_KM, djiBoundsEqual, makeDjiBaseGrid, splitDjiCell, } from "../../shared/dji-grid.js";
+/**
+ * Parse and fully validate a downloaded DJI snapshot.
+ *
+ * This is intentionally kept independent from Nitro/server runtime code so
+ * the updater and the runtime renderer cannot disagree about snapshot validity.
+ */
+export function parseDjiSnapshot(contents) {
+    const parsed = JSON.parse(contents);
+    if (!isRecord(parsed) || parsed.formatVersion !== 2 || parsed.source !== 'DJI FlySafe' || parsed.scope !== 'global')
+        invalidSnapshot();
+    if (!isIsoDate(parsed.startedAt) || !isIsoDate(parsed.completedAt) || parsed.fetchedAt !== parsed.completedAt)
+        invalidSnapshot();
+    if (Date.parse(parsed.startedAt) > Date.parse(parsed.completedAt))
+        invalidSnapshot();
+    const coverage = parsed.coverage;
+    if (!isRecord(coverage) || coverage.west !== DJI_COVERAGE.west || coverage.south !== DJI_COVERAGE.south || coverage.east !== DJI_COVERAGE.east || coverage.north !== DJI_COVERAGE.north)
+        invalidSnapshot();
+    const query = parsed.query;
+    if (!isRecord(query) || query.algorithmVersion !== 'global-adaptive-grid-v1' || query.endpoint !== DJI_ENDPOINT || query.zonesMode !== 'flysafe_website' || query.drone !== 'dji-mavic-3' || query.levels !== DJI_LEVELS)
+        invalidSnapshot();
+    if (query.rowDegrees !== DJI_ROW_DEGREES || query.targetDiagonalKm !== DJI_TARGET_DIAGONAL_KM || query.overlapDegrees !== DJI_OVERLAP_DEGREES || query.saturationLimit !== DJI_SATURATION_LIMIT || query.maxSplitDepth !== DJI_MAX_SPLIT_DEPTH)
+        invalidSnapshot();
+    if (!positiveInteger(query.queryCount) || !positiveInteger(query.baseQueryCount) || !nonNegativeInteger(query.recursiveQueryCount))
+        invalidSnapshot();
+    if (!nonNegativeInteger(query.saturatedQueryCount) || !nonNegativeInteger(query.maximumLeafResultCount) || query.allLeafQueriesBelowSaturationLimit !== true)
+        invalidSnapshot();
+    if (!nonNegativeInteger(query.occurrenceCount) || !nonNegativeInteger(query.uniqueAreaCount) || !nonNegativeInteger(query.duplicateOccurrences) || query.conflictingDuplicateCount !== 0 || !nonNegativeInteger(query.resumedQueryCount) || query.resumedQueryCount > query.queryCount)
+        invalidSnapshot();
+    if (!Array.isArray(query.queries) || query.queryCount !== query.queries.length || query.queryCount !== query.baseQueryCount + query.recursiveQueryCount)
+        invalidSnapshot();
+    if (!Array.isArray(parsed.areas) || query.uniqueAreaCount !== parsed.areas.length || query.duplicateOccurrences !== query.occurrenceCount - query.uniqueAreaCount)
+        invalidSnapshot();
+    if (typeof parsed.areasSha256 !== 'string' || !/^[0-9a-f]{64}$/.test(parsed.areasSha256))
+        invalidSnapshot();
+    if (createHash('sha256').update(JSON.stringify(parsed.areas)).digest('hex') !== parsed.areasSha256)
+        invalidSnapshot();
+    const queryIds = new Set();
+    const summaries = [];
+    let saturatedCount = 0;
+    let maximumLeafResultCount = 0;
+    let baseQueryCount = 0;
+    let occurrenceCount = 0;
+    for (const summary of query.queries) {
+        if (!isQuerySummary(summary) || queryIds.has(summary.id) || summary.depth > DJI_MAX_SPLIT_DEPTH)
+            invalidSnapshot();
+        queryIds.add(summary.id);
+        summaries.push(summary);
+        occurrenceCount += summary.resultCount;
+        if (summary.depth === 0)
+            baseQueryCount++;
+        if (summary.saturated) {
+            if (summary.resultCount < query.saturationLimit)
+                invalidSnapshot();
+            saturatedCount++;
+        }
+        else {
+            if (summary.resultCount >= query.saturationLimit)
+                invalidSnapshot();
+            maximumLeafResultCount = Math.max(maximumLeafResultCount, summary.resultCount);
+        }
+    }
+    if (baseQueryCount !== query.baseQueryCount || summaries.length - baseQueryCount !== query.recursiveQueryCount || occurrenceCount !== query.occurrenceCount)
+        invalidSnapshot();
+    if (saturatedCount !== query.saturatedQueryCount || maximumLeafResultCount !== query.maximumLeafResultCount)
+        invalidSnapshot();
+    const summariesById = new Map(summaries.map(summary => [summary.id, summary]));
+    const expectedBaseCells = makeDjiBaseGrid();
+    if (query.baseQueryCount !== expectedBaseCells.length)
+        invalidSnapshot();
+    for (const expected of expectedBaseCells) {
+        const actual = summariesById.get(expected.id);
+        if (!actual || actual.depth !== 0 || actual.parentId !== undefined || !djiBoundsEqual(actual.bounds, expected.bounds))
+            invalidSnapshot();
+    }
+    for (const summary of summaries) {
+        if (summary.depth === 0)
+            continue;
+        const parent = summary.parentId ? summariesById.get(summary.parentId) : undefined;
+        if (!parent?.saturated || parent.depth + 1 !== summary.depth)
+            invalidSnapshot();
+    }
+    for (const parent of summaries) {
+        const children = summaries.filter(summary => summary.parentId === parent.id);
+        if (!parent.saturated) {
+            if (children.length)
+                invalidSnapshot();
+            continue;
+        }
+        const expectedChildren = splitDjiCell(parent);
+        if (children.length !== expectedChildren.length)
+            invalidSnapshot();
+        for (const expected of expectedChildren) {
+            const actual = summariesById.get(expected.id);
+            if (!actual || actual.parentId !== parent.id || actual.depth !== expected.depth || !djiBoundsEqual(actual.bounds, expected.bounds))
+                invalidSnapshot();
+        }
+    }
+    const areaIds = new Set();
+    for (const area of parsed.areas) {
+        if (!isRecord(area) || area.area_id === null || area.area_id === undefined || String(area.area_id).trim() === '')
+            invalidSnapshot();
+        const id = String(area.area_id);
+        if (areaIds.has(id))
+            invalidSnapshot();
+        areaIds.add(id);
+    }
+    return parsed;
+}
+function isQuerySummary(value) {
+    if (!isRecord(value) || typeof value.id !== 'string' || !value.id || !nonNegativeInteger(value.depth) || !nonNegativeInteger(value.resultCount) || typeof value.saturated !== 'boolean')
+        return false;
+    if (value.parentId !== undefined && (typeof value.parentId !== 'string' || !value.parentId))
+        return false;
+    if (!Array.isArray(value.bounds) || value.bounds.length !== 4 || !value.bounds.every(item => typeof item === 'number' && Number.isFinite(item)))
+        return false;
+    const [west, south, east, north] = value.bounds;
+    return west >= -180 && east <= 180 && south >= -90 && north <= 90 && west < east && south < north;
+}
+function isIsoDate(value) {
+    return typeof value === 'string' && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function positiveInteger(value) {
+    return Number.isInteger(value) && Number(value) > 0;
+}
+function nonNegativeInteger(value) {
+    return Number.isInteger(value) && Number(value) >= 0;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function invalidSnapshot() {
+    throw new Error('DJI Flysafe 快照格式或完整性校验失败');
+}

package/dist/src/core/map-layer-paths.js

@@ -0,0 +1,11 @@
+import { resolve } from 'node:path';
+export const MAP_LAYER_SNAPSHOT_FILENAMES = {
+    dji: 'dji-nfz.json',
+    antigravity: 'antigravity-nfz.sqlite',
+};
+export function resolveMapLayerSnapshotPath(options) {
+    const explicitPath = options.explicitPath?.trim();
+    if (explicitPath)
+        return resolve(explicitPath);
+    return resolve(options.dataDir, 'map-layers', options.filename);
+}