@edmund32/edx-cli 0.1.2

package/src/image/split.mjs

@@ -0,0 +1,271 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import sharp from 'sharp';
+
+const IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+
+export function isImageFile(filePath) {
+  return IMAGE_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+export function parsePositiveInteger(value, name) {
+  const parsed = Number(value);
+
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`${name} 必须是正整数`);
+  }
+
+  return parsed;
+}
+
+export function parsePoint(value, name) {
+  if (!value) {
+    throw new Error(`${name} 缺少坐标值`);
+  }
+
+  const parts = value.split(',').map((part) => Number(part.trim()));
+
+  if (parts.length !== 2 || parts.some((part) => !Number.isFinite(part) || part < 0 || part > 1)) {
+    throw new Error(`${name} 必须是 0-1 比例坐标，格式如 0.5,0`);
+  }
+
+  return {
+    x: parts[0],
+    y: parts[1],
+  };
+}
+
+export function buildOutputRoot(targetPath) {
+  const absoluteTarget = path.resolve(targetPath);
+  const parent = path.dirname(absoluteTarget);
+  const name = path.basename(absoluteTarget);
+
+  return path.join(parent, `${name}_output`);
+}
+
+export function discoverImages(targetPath) {
+  const absoluteTarget = path.resolve(targetPath);
+
+  if (!fs.existsSync(absoluteTarget)) {
+    throw new Error(`找不到 target: ${targetPath}`);
+  }
+
+  const stat = fs.statSync(absoluteTarget);
+
+  if (stat.isFile()) {
+    if (!isImageFile(absoluteTarget)) {
+      return [];
+    }
+
+    return [
+      {
+        filePath: absoluteTarget,
+        relativeDir: '',
+        targetRoot: path.dirname(absoluteTarget),
+      },
+    ];
+  }
+
+  if (!stat.isDirectory()) {
+    throw new Error(`target 不是文件或目录: ${targetPath}`);
+  }
+
+  const images = [];
+
+  function walk(currentDir) {
+    const entries = fs.readdirSync(currentDir).sort((a, b) => a.localeCompare(b, 'zh-Hans-CN'));
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry);
+      const entryStat = fs.statSync(fullPath);
+
+      if (entryStat.isDirectory()) {
+        walk(fullPath);
+      } else if (entryStat.isFile() && isImageFile(fullPath)) {
+        images.push({
+          filePath: fullPath,
+          relativeDir: path.relative(absoluteTarget, path.dirname(fullPath)),
+          targetRoot: absoluteTarget,
+        });
+      }
+    }
+  }
+
+  walk(absoluteTarget);
+  return images;
+}
+
+function outputBaseDir(image, outputRoot) {
+  if (!image.relativeDir) {
+    return outputRoot;
+  }
+
+  return path.join(
+    outputRoot,
+    ...image.relativeDir.split(path.sep).filter(Boolean).map((segment) => `${segment}_output`),
+  );
+}
+
+function imageStem(filePath) {
+  return path.basename(filePath, path.extname(filePath));
+}
+
+function cellFileName(stem, index) {
+  return `${stem}_${String(index).padStart(3, '0')}.png`;
+}
+
+function clampExtractBox(box, meta) {
+  const left = Math.max(0, Math.min(box.left, meta.width - 1));
+  const top = Math.max(0, Math.min(box.top, meta.height - 1));
+  const maxWidth = meta.width - left;
+  const maxHeight = meta.height - top;
+
+  return {
+    left,
+    top,
+    width: Math.max(1, Math.min(box.width, maxWidth)),
+    height: Math.max(1, Math.min(box.height, maxHeight)),
+  };
+}
+
+export function regionToExtractBox(meta, from, to) {
+  if (!meta.width || !meta.height) {
+    throw new Error('无法读取图片尺寸');
+  }
+
+  if (from.x >= to.x || from.y >= to.y) {
+    throw new Error('--from 必须位于 --to 的左下方');
+  }
+
+  const left = Math.round(from.x * meta.width);
+  const right = Math.round(to.x * meta.width);
+  const bottom = Math.round(from.y * meta.height);
+  const topFromBottom = Math.round(to.y * meta.height);
+
+  return clampExtractBox(
+    {
+      left,
+      top: meta.height - topFromBottom,
+      width: right - left,
+      height: topFromBottom - bottom,
+    },
+    meta,
+  );
+}
+
+async function writeGridImage(image, outputRoot, rows, cols) {
+  const stem = imageStem(image.filePath);
+  const outputDir = path.join(outputBaseDir(image, outputRoot), stem);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const source = sharp(image.filePath);
+  const meta = await source.metadata();
+
+  if (!meta.width || !meta.height) {
+    throw new Error('无法读取图片尺寸');
+  }
+
+  const cellWidth = Math.floor(meta.width / cols);
+  const cellHeight = Math.floor(meta.height / rows);
+  let index = 1;
+  const outputs = [];
+
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      const left = col * cellWidth;
+      const top = row * cellHeight;
+      const width = col === cols - 1 ? meta.width - left : cellWidth;
+      const height = row === rows - 1 ? meta.height - top : cellHeight;
+      const outputPath = path.join(outputDir, cellFileName(stem, index));
+
+      await sharp(image.filePath)
+        .extract(clampExtractBox({ left, top, width, height }, meta))
+        .png()
+        .toFile(outputPath);
+
+      outputs.push(outputPath);
+      index += 1;
+    }
+  }
+
+  return outputs;
+}
+
+async function writeRegionImage(image, outputRoot, from, to) {
+  const outputDir = outputBaseDir(image, outputRoot);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const meta = await sharp(image.filePath).metadata();
+  const box = regionToExtractBox(meta, from, to);
+  const outputPath = path.join(outputDir, `${imageStem(image.filePath)}.png`);
+
+  await sharp(image.filePath).extract(box).png().toFile(outputPath);
+
+  return [outputPath];
+}
+
+function displayPath(filePath) {
+  return path.basename(filePath);
+}
+
+async function processImages(images, handler) {
+  const outputs = [];
+  const errors = [];
+  const logs = [];
+  const total = images.length;
+
+  if (total === 0) {
+    logs.push('未找到可处理图片');
+  }
+
+  let current = 0;
+
+  for (const image of images) {
+    current += 1;
+    const label = displayPath(image.filePath);
+    logs.push(`处理 ${current}/${total}: ${label}`);
+
+    try {
+      const imageOutputs = await handler(image);
+      outputs.push(...imageOutputs);
+      logs.push(`完成 ${current}/${total}: ${label} -> ${imageOutputs.length} 个文件`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push({
+        filePath: image.filePath,
+        message,
+      });
+      logs.push(`失败 ${current}/${total}: ${label} -> ${message}`);
+    }
+  }
+
+  return { outputs, errors, logs };
+}
+
+export async function splitGrid(targetPath, options) {
+  const rows = parsePositiveInteger(options.rows, '--rows');
+  const cols = parsePositiveInteger(options.cols, '--cols');
+  const images = discoverImages(targetPath);
+  const outputRoot = buildOutputRoot(targetPath);
+  const result = await processImages(images, (image) => writeGridImage(image, outputRoot, rows, cols));
+
+  return {
+    outputRoot,
+    modeLabel: 'grid 分割',
+    ...result,
+  };
+}
+
+export async function splitRegion(targetPath, options) {
+  const from = parsePoint(options.from, '--from');
+  const to = parsePoint(options.to, '--to');
+  const images = discoverImages(targetPath);
+  const outputRoot = buildOutputRoot(targetPath);
+  const result = await processImages(images, (image) => writeRegionImage(image, outputRoot, from, to));
+
+  return {
+    outputRoot,
+    modeLabel: 'region 裁切',
+    ...result,
+  };
+}

package/src/platform/platform.mjs

@@ -0,0 +1,13 @@
+export function detectPlatform(value = process.platform) {
+  if (value === 'darwin') {
+    return 'macos';
+  }
+  if (value === 'win32') {
+    return 'windows';
+  }
+  if (value === 'linux') {
+    return 'linux';
+  }
+
+  return 'unknown';
+}

package/src/utils/paths.mjs

@@ -0,0 +1,8 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+export function fromRoot(...segments) {
+  return path.join(PROJECT_ROOT, ...segments);
+}

package/src/utils/process.mjs

@@ -0,0 +1,26 @@
+import { spawnSync } from 'node:child_process';
+
+export function commandExists(command) {
+  const probe = process.platform === 'win32' ? 'where' : 'command';
+  const args = process.platform === 'win32' ? [command] : ['-v', command];
+  const result = spawnSync(probe, args, {
+    shell: process.platform !== 'win32',
+    stdio: 'ignore',
+  });
+
+  return result.status === 0;
+}
+
+export function runCommand(command, args = [], options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd ?? process.cwd(),
+    encoding: 'utf8',
+    shell: options.shell ?? false,
+  });
+
+  return {
+    code: result.status ?? 1,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  };
+}

package/src/utils/result.mjs

@@ -0,0 +1,17 @@
+export function ok(stdout = '', extra = {}) {
+  return {
+    code: 0,
+    stdout,
+    stderr: '',
+    ...extra,
+  };
+}
+
+export function fail(stderr, extra = {}) {
+  return {
+    code: 1,
+    stdout: '',
+    stderr,
+    ...extra,
+  };
+}