@ives_xxz/packages 1.0.1 → 1.0.3

package/FWMultiSkin/main.js

@@ -0,0 +1,320 @@
+const FS = require('fire-fs');
+const Path = require('path');
+
+module.exports = {
+  backupMap: new Map(),
+  isProcessing: false,
+
+  load() {
+    Editor.log('[皮肤管理器] 插件加载');
+    Editor.Builder.on('build-start', this.onBuildStart.bind(this));
+    Editor.Builder.on('build-finished', this.onBuildFinished.bind(this));
+  },
+
+  unload() {
+    Editor.log('[皮肤管理器] 插件卸载');
+    Editor.Builder.removeListener('build-start', this.onBuildStart);
+    Editor.Builder.removeListener('build-finished', this.onBuildFinished);
+  },
+
+  messages: {
+    open() {
+      Editor.Panel.open('multi-skin');
+    },
+
+    'get-config'(event) {
+      try {
+        const config = this.loadConfig();
+        Editor.log('[皮肤管理器] 返回配置给面板:', config);
+        if (event.reply) {
+          event.reply(null, config);
+        }
+        return config;
+      } catch (error) {
+        Editor.error('[皮肤管理器] 获取配置失败:', error);
+        if (event.reply) {
+          event.reply(error, null);
+        }
+        return null;
+      }
+    },
+
+    'save-config'(event, config) {
+      try {
+        const configPath = Path.join(__dirname, '../../../../', 'skin-config.json');
+        FS.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        Editor.log('[皮肤管理器] 保存配置成功:', config);
+
+        if (event.reply) {
+          event.reply(null, { success: true });
+        }
+        return { success: true };
+      } catch (error) {
+        Editor.error('[皮肤管理器] 保存配置失败:', error);
+        if (event.reply) {
+          event.reply(null, { success: false, error: error.message });
+        }
+        return { success: false, error: error.message };
+      }
+    },
+  },
+
+  loadConfig() {
+    try {
+      const configPath = Path.join(__dirname, '../../../../', 'skin-config.json');
+
+      if (FS.existsSync(configPath)) {
+        const content = FS.readFileSync(configPath, 'utf8');
+        return JSON.parse(content);
+      } else {
+        const defaultConfig = { enabled: false, currentSkin: '' };
+        FS.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+        return defaultConfig;
+      }
+    } catch (error) {
+      Editor.warn('[皮肤管理器] 加载配置失败:', error);
+      return { enabled: false, currentSkin: '' };
+    }
+  },
+
+  findAllSkinDirectories() {
+    const projectPath = Editor.Project.path;
+    const assetsPath = Path.join(projectPath, 'assets');
+    const skinDirectories = [];
+
+    const findSkinDirs = (dirPath) => {
+      try {
+        const items = FS.readdirSync(dirPath);
+
+        for (const item of items) {
+          const fullPath = Path.join(dirPath, item);
+
+          try {
+            const stat = FS.statSync(fullPath);
+
+            if (stat.isDirectory()) {
+              if (item.toLowerCase() === 'skin') {
+                const skinItems = FS.readdirSync(fullPath);
+                for (const skinItem of skinItems) {
+                  const skinItemPath = Path.join(fullPath, skinItem);
+                  try {
+                    const skinStat = FS.statSync(skinItemPath);
+                    if (skinStat.isDirectory()) {
+                      const metaPath = skinItemPath + '.meta';
+                      const hasMeta = FS.existsSync(metaPath);
+
+                      skinDirectories.push({
+                        skinName: skinItem,
+                        skinPath: skinItemPath,
+                        metaPath: hasMeta ? metaPath : null,
+                        parentPath: fullPath,
+                        relativePath: Path.relative(assetsPath, skinItemPath),
+                      });
+                    }
+                  } catch (e) {}
+                }
+              }
+
+              findSkinDirs(fullPath);
+            }
+          } catch (e) {}
+        }
+      } catch (error) {}
+    };
+
+    if (FS.existsSync(assetsPath)) {
+      findSkinDirs(assetsPath);
+    }
+
+    return skinDirectories;
+  },
+
+  onBuildStart(options, callback) {
+    if (this.isProcessing) {
+      Editor.log('[皮肤管理器] 正在处理，跳过');
+      callback();
+      return;
+    }
+
+    this.isProcessing = true;
+
+    try {
+      const config = this.loadConfig();
+
+      if (!config.enabled) {
+        Editor.log('[皮肤管理器] 功能未启用，跳过处理');
+        this.isProcessing = false;
+        callback();
+        return;
+      }
+
+      const currentSkin = config.currentSkin;
+      if (!currentSkin) {
+        Editor.warn('[皮肤管理器] 未指定当前皮肤，跳过处理');
+        this.isProcessing = false;
+        callback();
+        return;
+      }
+
+      Editor.log(`[皮肤管理器] 构建开始，处理皮肤资源，保留: ${currentSkin}`);
+
+      this.backupMap.clear();
+
+      const projectPath = Editor.Project.path;
+      const backupRoot = Path.join(projectPath, 'backups');
+      if (!FS.existsSync(backupRoot)) {
+        FS.mkdirSync(backupRoot);
+      }
+
+      const skinDirectories = this.findAllSkinDirectories();
+      Editor.log(`[皮肤管理器] 找到 ${skinDirectories.length} 个皮肤目录`);
+
+      let movedCount = 0;
+
+      for (const directory of skinDirectories) {
+        if (directory.skinName === currentSkin) {
+          Editor.log(`[皮肤管理器] 保留: ${directory.relativePath}`);
+          continue;
+        }
+
+        const relativeToAssets = Path.relative(
+          Path.join(projectPath, 'assets'),
+          directory.skinPath
+        );
+        const backupPath = Path.join(backupRoot, relativeToAssets);
+        const backupMetaPath = backupPath + '.meta';
+
+        const backupDir = Path.dirname(backupPath);
+        if (!FS.existsSync(backupDir)) {
+          FS.mkdirsSync(backupDir);
+        }
+
+        try {
+          FS.renameSync(directory.skinPath, backupPath);
+
+          if (directory.metaPath && FS.existsSync(directory.metaPath)) {
+            FS.renameSync(directory.metaPath, backupMetaPath);
+            Editor.log(`[皮肤管理器] 已移动.meta文件: ${directory.metaPath}`);
+          }
+
+          this.backupMap.set(directory.skinPath, {
+            backupPath: backupPath,
+            backupMetaPath: directory.metaPath ? backupMetaPath : null,
+            originalMetaPath: directory.metaPath,
+            skinName: directory.skinName,
+            parentPath: directory.parentPath,
+          });
+
+          movedCount++;
+
+          Editor.log(`[皮肤管理器] 已移动: ${directory.relativePath}`);
+        } catch (error) {
+          Editor.error(`[皮肤管理器] 移动失败: ${directory.skinPath}`, error);
+          if (FS.existsSync(backupPath)) {
+            try {
+              FS.renameSync(backupPath, directory.skinPath);
+              if (FS.existsSync(backupMetaPath) && directory.metaPath) {
+                FS.renameSync(backupMetaPath, directory.metaPath);
+              }
+            } catch (recoveryError) {
+              Editor.error(`[皮肤管理器] 恢复失败: ${directory.skinPath}`, recoveryError);
+            }
+          }
+        }
+      }
+
+      Editor.log(`[皮肤管理器] 已移动 ${movedCount} 个非当前皮肤目录到备份文件夹`);
+
+      setTimeout(() => {
+        this.isProcessing = false;
+        callback?.();
+      }, 500);
+    } catch (error) {
+      Editor.error('[皮肤管理器] 处理皮肤文件夹失败:', error);
+
+      this.restoreSkinFolders().finally(() => {
+        this.isProcessing = false;
+        callback?.(error);
+      });
+    }
+  },
+
+  onBuildFinished(options, result, callback) {
+    Editor.log('[皮肤管理器] 构建完成，开始恢复皮肤文件夹');
+
+    this.restoreSkinFolders()
+      .then(() => {
+        callback?.();
+      })
+      .catch((error) => {
+        Editor.error('[皮肤管理器] 恢复皮肤文件夹失败:', error);
+        callback?.(error);
+      });
+  },
+
+  restoreSkinFolders() {
+    return new Promise((resolve, reject) => {
+      if (this.backupMap.size === 0) {
+        resolve();
+        return;
+      }
+
+      Editor.log('[皮肤管理器] 开始恢复皮肤文件夹...');
+      let restoredCount = 0;
+
+      for (const [originalPath, backupInfo] of this.backupMap) {
+        const { backupPath, backupMetaPath, originalMetaPath } = backupInfo;
+
+        try {
+          if (FS.existsSync(backupPath)) {
+            if (FS.existsSync(originalPath)) {
+              FS.removeSync(originalPath);
+            }
+
+            if (originalMetaPath && FS.existsSync(originalMetaPath)) {
+              FS.removeSync(originalMetaPath);
+            }
+
+            const originalDir = Path.dirname(originalPath);
+            if (!FS.existsSync(originalDir)) {
+              FS.mkdirsSync(originalDir);
+            }
+
+            FS.renameSync(backupPath, originalPath);
+
+            if (backupMetaPath && FS.existsSync(backupMetaPath) && originalMetaPath) {
+              FS.renameSync(backupMetaPath, originalMetaPath);
+              Editor.log(`[皮肤管理器] 已恢复.meta文件: ${originalMetaPath}`);
+            }
+
+            restoredCount++;
+
+            Editor.log(`[皮肤管理器] 已恢复: ${originalPath}`);
+          } else {
+            Editor.warn(`[皮肤管理器] 备份文件不存在: ${backupPath}`);
+          }
+        } catch (error) {
+          Editor.error(`[皮肤管理器] 恢复失败: ${originalPath}`, error);
+        }
+      }
+
+      try {
+        const projectPath = Editor.Project.path;
+        const backupRoot = Path.join(projectPath, 'backups');
+        if (FS.existsSync(backupRoot)) {
+          FS.removeSync(backupRoot);
+          Editor.log(`[皮肤管理器] 已删除备份文件夹: ${backupRoot}`);
+        }
+      } catch (error) {
+        Editor.error('[皮肤管理器] 删除备份文件夹失败:', error);
+      }
+
+      this.backupMap.clear();
+      Editor.log(`[皮肤管理器] 恢复完成，共恢复 ${restoredCount} 个文件夹`);
+
+      setTimeout(() => {
+        resolve();
+      }, 500);
+    });
+  },
+};

package/FWMultiSkin/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "multi-skin",
+  "version": "1.0.0",
+  "description": "皮肤构建管理插件",
+  "author": "ives",
+  "main": "main.js",
+  "main-menu": {
+    "i18n:MAIN_MENU.package.title/皮肤管理器": {
+      "message": "multi-skin:open"
+    }
+  },
+  "panel": {
+    "main": "panel/index.js",
+    "type": "dockable",
+    "title": "皮肤管理器",
+    "width": 1334,
+    "height": 600
+  },
+  "contributions": {
+    "builder": {
+      "hooks": "./main.js"
+    }
+  }
+}

package/FWMultiSkin/panel/index.js

@@ -0,0 +1,306 @@
+Editor.Panel.extend({
+  style: `
+    .container {
+      padding: 20px;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    }
+    
+    .header {
+      margin-bottom: 30px;
+      padding-bottom: 15px;
+      border-bottom: 2px solid #1890ff;
+    }
+    
+    .config-section {
+      margin-bottom: 30px;
+      padding: 20px;
+      background: #f6f8fa;
+      border-radius: 6px;
+      border: 1px solid #e1e4e8;
+    }
+    
+    .config-row {
+      display: flex;
+      align-items: center;
+      margin-bottom: 15px;
+    }
+    
+    .config-label {
+      width: 120px;
+      font-weight: 500;
+      font-size: 14px;
+    }
+    
+    .skin-input {
+      flex: 1;
+      padding: 8px 12px;
+      border: 1px solid #d9d9d9;
+      border-radius: 4px;
+      font-size: 14px;
+    }
+    
+    .tip {
+      font-size: 12px;
+      color: #666;
+      margin-top: 8px;
+    }
+    
+    .tip code {
+      background: #f0f0f0;
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-family: monospace;
+    }
+    
+    .footer {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-top: 20px;
+    }
+    
+    .message {
+      padding: 10px 15px;
+      border-radius: 4px;
+      margin-bottom: 15px;
+      font-size: 13px;
+      display: none;
+    }
+    
+    .message.success {
+      background: #f6ffed;
+      border: 1px solid #b7eb8f;
+      color: #52c41a;
+      display: block;
+    }
+    
+    .message.error {
+      background: #fff2f0;
+      border: 1px solid #ffccc7;
+      color: #f5222d;
+      display: block;
+    }
+    
+    .message.info {
+      background: #e6f7ff;
+      border: 1px solid #91d5ff;
+      color: #1890ff;
+      display: block;
+    }
+    
+    .status {
+      font-size: 14px;
+      font-weight: 500;
+      min-height: 24px;
+      display: flex;
+      align-items: center;
+    }
+    
+    .status-icon {
+      display: inline-block;
+      margin-right: 6px;
+      font-size: 16px;
+    }
+    
+    .loading {
+      opacity: 0.6;
+      pointer-events: none;
+    }
+  `,
+
+  template: `
+    <div class="container" id="container">
+      <div class="header">
+        <h2>🎨 皮肤管理器</h2>
+        <p>构建时只保留指定皮肤，自动剔除其他skin文件夹</p>
+      </div>
+      
+      <div class="config-section">
+        <div class="config-row">
+          <div class="config-label">当前皮肤：</div>
+          <input 
+            type="text" 
+            class="skin-input" 
+            id="skinInput" 
+            placeholder="请输入皮肤名称"
+            disabled
+          >
+        </div>
+        
+        <div class="config-row">
+          <div class="config-label">启用功能：</div>
+          <ui-checkbox id="enableCheckbox" disabled></ui-checkbox>
+        </div>
+      </div>
+      
+      <div class="message" id="message"></div>
+      
+      <div class="footer">
+        <div class="status" id="status">
+          <span class="status-icon">⏳</span>
+          <span>正在加载配置...</span>
+        </div>
+        <div>
+          <ui-button id="saveBtn" class="green" disabled>💾 保存配置</ui-button>
+        </div>
+      </div>
+    </div>
+  `,
+
+  $: {
+    container: '#container',
+    skinInput: '#skinInput',
+    enableCheckbox: '#enableCheckbox',
+    saveBtn: '#saveBtn',
+    message: '#message',
+    status: '#status',
+  },
+
+  ready() {
+    Editor.log('皮肤管理器面板已加载');
+
+    this.$saveBtn.addEventListener('confirm', () => {
+      this.saveConfig();
+    });
+
+    this.$skinInput.addEventListener('input', () => {
+      this.updateStatus();
+    });
+
+    this.$skinInput.addEventListener('change', () => {
+      this.updateStatus();
+    });
+
+    this.$enableCheckbox.addEventListener('change', () => {
+      this.updateStatus();
+    });
+
+    this.loadConfig();
+  },
+
+  async loadConfig() {
+    try {
+      this.showMessage('正在加载配置...', 'info');
+
+      const config = await new Promise((resolve, reject) => {
+        Editor.Ipc.sendToMain('multi-skin:get-config', (error, result) => {
+          if (error) reject(error);
+          else resolve(result);
+        });
+      });
+
+      Editor.log('从IPC加载到的配置:', config);
+
+      if (!config) {
+        throw new Error('配置加载为空');
+      }
+
+      this.$skinInput.value = config.currentSkin || '';
+      this.$enableCheckbox.checked = config.enabled || false;
+
+      this.$skinInput.disabled = false;
+      this.$enableCheckbox.disabled = false;
+      this.$saveBtn.disabled = false;
+      this.$container.classList.remove('loading');
+
+      this.updateStatus(true);
+
+      if (config.currentSkin) {
+        this.showMessage(
+          `配置已加载: ${config.enabled ? '启用' : '禁用'} - 皮肤: ${config.currentSkin}`,
+          'success'
+        );
+      } else {
+        this.showMessage('配置已加载，未设置皮肤', 'info');
+      }
+    } catch (error) {
+      Editor.error('加载配置失败:', error);
+      this.showMessage(`加载配置失败: ${error.message}，使用默认配置`, 'error');
+
+      this.$skinInput.value = '';
+      this.$enableCheckbox.checked = false;
+      this.$skinInput.disabled = false;
+      this.$enableCheckbox.disabled = false;
+      this.$saveBtn.disabled = false;
+      this.$container.classList.remove('loading');
+      this.updateStatus(true);
+    }
+  },
+
+  updateStatus(isInitialLoad = false) {
+    const enabled = this.$enableCheckbox.checked;
+    const skin = this.$skinInput.value.trim();
+
+    let icon = '';
+    let text = '';
+    let color = '';
+
+    if (!enabled) {
+      icon = '⭕';
+      text = skin ? `功能已禁用 (配置皮肤: ${skin})` : '功能已禁用，未设置皮肤';
+      color = '#999';
+    } else if (!skin) {
+      icon = '⚠️';
+      text = '请填写皮肤名称';
+      color = '#faad14';
+    } else {
+      icon = '✅';
+      text = `已启用，将保留皮肤: ${skin}`;
+      color = '#52c41a';
+    }
+
+    this.$status.innerHTML = `<span class="status-icon">${icon}</span><span>${text}</span>`;
+    this.$status.style.color = color;
+  },
+
+  async saveConfig() {
+    const enabled = this.$enableCheckbox.checked;
+    const skin = this.$skinInput.value.trim();
+
+    if (enabled && !skin) {
+      this.showMessage('启用功能时必须填写皮肤名称', 'error');
+      return;
+    }
+
+    try {
+      const config = {
+        enabled: enabled,
+        currentSkin: skin,
+      };
+
+      const result = await new Promise((resolve, reject) => {
+        Editor.Ipc.sendToMain('multi-skin:save-config', config, (error, result) => {
+          if (error) reject(error);
+          else resolve(result);
+        });
+      });
+
+      if (result.success) {
+        let message = '配置已保存';
+        if (enabled) {
+          message += `，构建时将保留皮肤: ${skin}`;
+        } else {
+          message += '，功能已禁用';
+        }
+        this.showMessage(message, 'success');
+        this.updateStatus();
+      } else {
+        this.showMessage('保存失败: ' + (result.error || '未知错误'), 'error');
+      }
+    } catch (error) {
+      Editor.error('保存配置失败:', error);
+      this.showMessage(`保存失败: ${error.message}`, 'error');
+    }
+  },
+
+  showMessage(text, type = 'info') {
+    const msg = this.$message;
+    msg.textContent = text;
+    msg.className = 'message ' + type;
+
+    setTimeout(() => {
+      msg.className = 'message';
+      msg.textContent = '';
+    }, 3000);
+  },
+});

package/PNG Auto Compress/config-manager.js

@@ -9,7 +9,7 @@ const configFileName = 'ccc-png-auto-compress.json';
 
 /** 默认配置 */
 const defaultConfig = {
-    enabled: true,
+    enabled: false,
     minQuality: 40,
     maxQuality: 80,
     colors: 256,

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@ives_xxz/packages",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "cocoscreator 2.x plugins",
   "main": "index.js",
-  "scripts": {
-  },
+  "scripts": {},
   "keywords": ["123456"],
   "author": "ives",
   "license": "ISC"
-  
 }