lanhu-layer-tree 1.0.0

package/src/assets.ts

@@ -0,0 +1,221 @@
+/**
+ * 资源处理：图片尺寸读取、Cocos/Unity meta 文件处理
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+/**
+ * 生成 UUID v4
+ */
+function generateUuid(): string {
+  return crypto.randomUUID();
+}
+
+/**
+ * 读取 PNG 图片尺寸
+ */
+export function readPngSize(filePath: string): [number, number] {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const buffer = Buffer.alloc(24);
+    fs.readSync(fd, buffer, 0, 24, 0);
+    // PNG: 8 字节签名 + 4 字节长度 + 4 字节类型 + 4 字节宽 + 4 字节高
+    const width = buffer.readUInt32BE(16);
+    const height = buffer.readUInt32BE(20);
+    return [width, height];
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/**
+ * 读取 JPEG 图片尺寸
+ */
+export function readJpegSize(filePath: string): [number, number] {
+  const data = fs.readFileSync(filePath);
+  let i = 2;
+  while (i < data.length) {
+    if (data[i] !== 0xff) break;
+    const marker = data[i + 1];
+    const length = data.readUInt16BE(i + 2);
+    if (marker === 0xc0 || marker === 0xc1 || marker === 0xc2) {
+      const height = data.readUInt16BE(i + 5);
+      const width = data.readUInt16BE(i + 7);
+      return [width, height];
+    }
+    i += 2 + length;
+  }
+  throw new Error(`无法读取 JPEG 尺寸: ${filePath}`);
+}
+
+/**
+ * 获取图片尺寸（支持 PNG/JPEG/WEBP）
+ */
+export function getImageSize(filePath: string): [number, number] {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.png') return readPngSize(filePath);
+  if (ext === '.jpg' || ext === '.jpeg') return readJpegSize(filePath);
+
+  // WEBP (VP8)
+  const data = Buffer.alloc(30);
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    fs.readSync(fd, data, 0, 30, 0);
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  if (
+    data.slice(0, 4).toString() === 'RIFF' &&
+    data.slice(8, 12).toString() === 'WEBP' &&
+    data.slice(12, 16).toString() === 'VP8 '
+  ) {
+    const width = data.readUInt16LE(26) & 0x3fff;
+    const height = data.readUInt16LE(28) & 0x3fff;
+    return [width, height];
+  }
+
+  throw new Error(`不支持的图片格式: ${filePath}`);
+}
+
+/**
+ * 生成 Cocos Creator .meta 文件内容
+ */
+export function makeCocosMeta(imgPath: string): any {
+  const [w, h] = getImageSize(imgPath);
+  const textureUuid = generateUuid();
+  const spriteUuid = generateUuid();
+  const stem = path.basename(imgPath, path.extname(imgPath));
+
+  return {
+    ver: '2.3.5',
+    uuid: textureUuid,
+    type: 'sprite',
+    wrapMode: 'clamp',
+    filterMode: 'bilinear',
+    premultiplyAlpha: false,
+    genMipmaps: false,
+    packable: true,
+    width: w,
+    height: h,
+    platformSettings: {},
+    subMetas: {
+      [stem]: {
+        ver: '1.0.4',
+        uuid: spriteUuid,
+        rawTextureUuid: textureUuid,
+        trimType: 'auto',
+        trimThreshold: 1,
+        rotated: false,
+        offsetX: 0,
+        offsetY: 0,
+        trimX: 0,
+        trimY: 0,
+        width: w,
+        height: h,
+        rawWidth: w,
+        rawHeight: h,
+        borderTop: 0,
+        borderBottom: 0,
+        borderLeft: 0,
+        borderRight: 0,
+        subMetas: {}
+      }
+    }
+  };
+}
+
+/**
+ * 从 Cocos .meta 文件中读取 spriteFrame UUID
+ */
+export function readCocosSpriteUuid(metaPath: string): string | null {
+  try {
+    const text = fs.readFileSync(metaPath, 'utf-8');
+    const data = JSON.parse(text);
+    const sub = data.subMetas || {};
+    const keys = Object.keys(sub);
+    if (keys.length > 0) {
+      return sub[keys[0]].uuid || null;
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+export interface UnityMetaInfo {
+  guid: string;
+  sliced: boolean;
+  border: [number, number, number, number] | null;
+}
+
+/**
+ * 从 Unity YAML .meta 文件中读取 guid 和 spriteBorder
+ * Unity spriteBorder 格式: x=left, y=bottom, z=right, w=top
+ */
+export function readUnityMeta(metaPath: string): UnityMetaInfo | null {
+  try {
+    const text = fs.readFileSync(metaPath, 'utf-8');
+    const guidMatch = text.match(/^guid:\s*([0-9a-f]+)/m);
+    if (!guidMatch) return null;
+    const guid = guidMatch[1];
+
+    let sliced = false;
+    let border: [number, number, number, number] | null = null;
+
+    const borderMatch = text.match(
+      /spriteBorder:\s*\{x:\s*([\d.]+),\s*y:\s*([\d.]+),\s*z:\s*([\d.]+),\s*w:\s*([\d.]+)\}/
+    );
+    if (borderMatch) {
+      const values = [
+        parseFloat(borderMatch[1]),
+        parseFloat(borderMatch[2]),
+        parseFloat(borderMatch[3]),
+        parseFloat(borderMatch[4])
+      ];
+      sliced = values.some(v => v !== 0);
+      if (sliced) {
+        border = [
+          Math.round(values[0]),
+          Math.round(values[1]),
+          Math.round(values[2]),
+          Math.round(values[3])
+        ];
+      }
+    }
+
+    return { guid, sliced, border };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 在 assetsDir 下递归搜索同名文件
+ */
+export function findLocalAsset(filename: string, assetsDir: string): string | null {
+  if (!fs.existsSync(assetsDir)) return null;
+
+  const stack: string[] = [assetsDir];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name === filename) {
+        return fullPath;
+      }
+    }
+  }
+  return null;
+}

package/src/cli.ts

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { config } from 'dotenv';
+import { LanhuClient } from './client';
+import { formatLayersTree } from './formatter';
+import { parseUrl } from './utils';
+import { calculateLayerSimilarity, mergeLayers } from './merger';
+import { refreshCookieFromChrome } from './cookie';
+import * as fs from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
+import * as path from 'path';
+
+// 加载 .env 文件
+config();
+
+const program = new Command();
+
+program
+  .name('lanhu')
+  .description('蓝湖设计图图层树提取工具')
+  .version('1.0.0');
+
+// list 命令：列出项目中的所有设计图
+program
+  .command('list')
+  .description('列出项目中的所有设计图')
+  .argument('<url>', '蓝湖项目 URL')
+  .option('-o, --output <file>', '输出文件路径')
+  .action(async (url: string, options: { output?: string }) => {
+    try {
+      const client = new LanhuClient();
+      const result = await client.getDesigns(url);
+      const output = JSON.stringify(result, null, 2);
+      if (options.output) {
+        await fs.writeFile(options.output, output, 'utf-8');
+        console.log(`✅ 设计图列表已保存到: ${options.output}`);
+      } else {
+        console.log(output);
+      }
+    } catch (error) {
+      console.error('❌ 错误:', error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// layers 命令：获取指定设计图的图层信息
+program
+  .command('layers')
+  .description('获取指定设计图的图层信息')
+  .argument('<url>', '蓝湖设计图 URL（如果包含 image_id 参数，可省略 design-id）')
+  .argument('[design-id]', '设计图 ID（可选）')
+  .option('-o, --output <file>', '输出文件路径')
+  .option('-t, --tree', '以树形结构输出图层信息')
+  .option('-e, --engine <type>', '引擎类型（unity/cocos），转换为引擎坐标系')
+  .option('-a, --assets-dir <dir>', '资源目录路径，用于解析资源 UUID')
+  .action(async (
+    urlArg: string,
+    designId: string | undefined,
+    options: {
+      output?: string;
+      tree?: boolean;
+      engine?: 'unity' | 'cocos';
+      assetsDir?: string;
+    }
+  ) => {
+    try {
+      if (options.engine && !['unity', 'cocos'].includes(options.engine)) {
+        console.error(`❌ 不支持的引擎类型: ${options.engine}，仅支持 unity/cocos`);
+        process.exit(1);
+      }
+
+      // 支持 @file 语法读取 URL
+      let urlInput = urlArg;
+      if (urlInput.startsWith('@')) {
+        const urlFile = urlInput.slice(1);
+        if (!existsSync(urlFile)) {
+          console.error(`❌ URL 文件不存在: ${urlFile}`);
+          process.exit(1);
+        }
+        urlInput = readFileSync(urlFile, 'utf-8').trim();
+        console.log(`✅ 从文件读取 URL: ${urlFile}`);
+      }
+
+      // 支持多 URL（逗号分隔）
+      const urls = urlInput.split(',').map(u => u.trim()).filter(Boolean);
+
+      const client = new LanhuClient();
+
+      if (urls.length === 1) {
+        const singleUrl = urls[0];
+        let did = designId;
+        if (!did) {
+          const params = parseUrl(singleUrl);
+          did = params.doc_id;
+          if (!did) {
+            console.error('❌ URL 中未找到 image_id 参数，请手动指定设计图ID');
+            process.exit(1);
+          }
+        }
+
+        const result = await client.getDesignLayers(singleUrl, did);
+        let output: string;
+        if (options.tree) {
+          output = formatLayersTree(
+            result.layers,
+            result.design_name,
+            result.canvas_size.width,
+            result.canvas_size.height,
+            { engine: options.engine, assetsDir: options.assetsDir }
+          );
+        } else {
+          output = JSON.stringify(result, null, 2);
+        }
+
+        if (options.output) {
+          await fs.writeFile(options.output, output, 'utf-8');
+          console.log(`✅ 图层信息已保存到: ${options.output}`);
+        } else {
+          console.log(output);
+        }
+        return;
+      }
+
+      // 多 URL：相似度 + 合并
+      console.log(`🔍 检测到 ${urls.length} 个 URL，开始获取图层信息...`);
+      const allResults = [];
+      const allLayers: any[][] = [];
+      const designNames: string[] = [];
+
+      for (let idx = 0; idx < urls.length; idx++) {
+        const u = urls[idx];
+        console.log(`\n📥 [${idx + 1}/${urls.length}] 获取图层: ${u.slice(0, 80)}...`);
+        const params = parseUrl(u);
+        const did = params.doc_id;
+        if (!did) {
+          console.error(`❌ URL ${idx + 1} 中未找到 image_id 参数`);
+          process.exit(1);
+        }
+        const r = await client.getDesignLayers(u, did);
+        allResults.push(r);
+        allLayers.push(r.layers);
+        designNames.push(r.design_name || `Design${idx + 1}`);
+        console.log(`✅ 获取成功: ${r.design_name} (${r.total_layers} 个图层)`);
+      }
+
+      console.log(`\n🔍 计算图层相似度...`);
+      const similarities: number[] = [];
+      for (let i = 0; i < allLayers.length - 1; i++) {
+        const sim = calculateLayerSimilarity(allLayers[i], allLayers[i + 1]);
+        similarities.push(sim);
+        console.log(`  ${designNames[i]} vs ${designNames[i + 1]}: ${sim.toFixed(2)}%`);
+      }
+
+      const minSim = similarities.length > 0 ? Math.min(...similarities) : 100;
+      console.log(`\n📊 最低相似度: ${minSim.toFixed(2)}%`);
+      if (minSim < 80) {
+        console.error(`\n❌ 错误: 图层相似度 (${minSim.toFixed(2)}%) 低于阈值 (80%)，无法合并`);
+        console.error('提示: 请确保所有设计图具有相似的图层结构');
+        process.exit(1);
+      }
+
+      console.log(`\n🔄 相似度检查通过，开始合并图层...`);
+      const merged = mergeLayers(allLayers, designNames);
+      console.log(`✅ 合并完成: ${merged.layers.length} 个图层`);
+
+      const canvasSize = allResults[0].canvas_size;
+      const mergedResult = {
+        design_id: 'merged',
+        design_name: merged.name,
+        version: 'merged',
+        canvas_size: canvasSize,
+        total_layers: merged.layers.length,
+        layers: merged.layers,
+        source_designs: allResults.map(r => ({
+          name: r.design_name,
+          id: r.design_id,
+          total_layers: r.total_layers
+        })),
+        similarities: similarities.map((s, i) => ({
+          pair: `${designNames[i]} vs ${designNames[i + 1]}`,
+          similarity: s
+        }))
+      };
+
+      let output: string;
+      if (options.tree) {
+        output = formatLayersTree(
+          merged.layers,
+          merged.name,
+          canvasSize.width,
+          canvasSize.height,
+          { engine: options.engine, assetsDir: options.assetsDir }
+        );
+      } else {
+        output = JSON.stringify(mergedResult, null, 2);
+      }
+
+      if (options.output) {
+        await fs.writeFile(options.output, output, 'utf-8');
+        console.log(`\n✅ 合并后的图层信息已保存到: ${options.output}`);
+      } else {
+        console.log(`\n${output}`);
+      }
+    } catch (error) {
+      console.error('❌ 错误:', error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// slices 命令：获取设计图切图列表
+program
+  .command('slices')
+  .description('获取指定设计图的切图列表')
+  .argument('<url>', '蓝湖设计图 URL')
+  .argument('[design-id]', '设计图 ID（可选）')
+  .option('-o, --output <file>', '输出文件路径（JSON）')
+  .option('-d, --download-dir <dir>', '指定目录则批量下载切图到该目录')
+  .action(async (
+    url: string,
+    designId: string | undefined,
+    options: { output?: string; downloadDir?: string }
+  ) => {
+    try {
+      if (!designId) {
+        const params = parseUrl(url);
+        designId = params.doc_id;
+        if (!designId) {
+          console.error('❌ URL 中未找到 image_id 参数，请手动指定设计图ID');
+          process.exit(1);
+        }
+      }
+
+      const client = new LanhuClient();
+      const result = await client.getDesignSlices(url, designId);
+
+      const output = JSON.stringify(result, null, 2);
+      if (options.output) {
+        await fs.writeFile(options.output, output, 'utf-8');
+        console.log(`✅ 切图列表已保存到: ${options.output}`);
+      } else if (!options.downloadDir) {
+        console.log(output);
+      }
+
+      if (options.downloadDir) {
+        console.log(`\n📥 开始批量下载 ${result.total_slices} 个切图到: ${options.downloadDir}`);
+        let okCount = 0;
+        for (const slice of result.slices) {
+          const ext = slice.format || 'png';
+          const safeName = slice.name.replace(/[\\/:*?"<>|]/g, '_') || 'slice';
+          const outPath = path.join(options.downloadDir, `${safeName}.${ext}`);
+          const ok = await client.downloadSlice(slice, outPath);
+          if (ok) okCount++;
+        }
+        console.log(`✅ 下载完成: ${okCount}/${result.total_slices}`);
+      }
+    } catch (error) {
+      console.error('❌ 错误:', error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// download 命令：下载设计图截图
+program
+  .command('download')
+  .description('下载设计图截图')
+  .argument('<url>', '蓝湖设计图 URL')
+  .argument('[design-id]', '设计图 ID（可选）')
+  .argument('[design-name]', '设计图名称（可选）')
+  .option('-d, --output-dir <dir>', '输出目录', '.')
+  .action(async (
+    url: string,
+    designId: string | undefined,
+    designName: string | undefined,
+    options: { outputDir: string }
+  ) => {
+    try {
+      if (!designId) {
+        const params = parseUrl(url);
+        designId = params.doc_id;
+        if (!designId) {
+          console.error('❌ URL 中未找到 image_id 参数，请手动指定设计图ID');
+          process.exit(1);
+        }
+      }
+
+      const client = new LanhuClient();
+      const designsResult = await client.getDesigns(url);
+
+      const design = designsResult.designs?.find(d => d.id === designId);
+      if (!design) {
+        console.error(`❌ 未找到设计图 ID: ${designId}`);
+        process.exit(1);
+      }
+
+      const name = designName || design.name;
+      const outputPath = path.join(options.outputDir, `${name}.png`);
+
+      const success = await client.downloadScreenshot(design, outputPath);
+      if (success) {
+        console.log(`✅ 截图已下载到: ${outputPath}`);
+      } else {
+        console.error('❌ 下载失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ 错误:', error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+// refresh-cookie 命令：从 Chrome 刷新蓝湖 cookie
+program
+  .command('refresh-cookie')
+  .description('从 Chrome 浏览器刷新蓝湖 cookie 并写入 .env 文件')
+  .argument('[env-file]', '.env 文件路径（默认为当前目录的 .env）')
+  .action(async (envFile: string | undefined) => {
+    try {
+      const envPath = envFile ? path.resolve(envFile) : path.resolve(process.cwd(), '.env');
+      const cookie = await refreshCookieFromChrome(envPath);
+      if (cookie) {
+        console.log('✅ Cookie 刷新成功');
+      } else {
+        console.error('❌ Cookie 刷新失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ 错误:', error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program.parse();