@phill-component/icons 0.1.6

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@phill-component/icons",
+  "version": "0.1.6",
+  "description": "Unified icons for phillUI mobile and pc libraries",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "bin": {
+    "phillui-icons": "scripts/install.js"
+  },
+  "scripts": {
+    "build": "node scripts/build.js",
+    "release-core-icons": "node ../../../scripts/publish-icons.js"
+  },
+  "keywords": [
+    "icons",
+    "vue",
+    "uniapp"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "svgo": "^4.0.0",
+    "svgtofont": "^6.5.1",
+    "case": "^1.6.3"
+  }
+}

package/scripts/build.js

@@ -0,0 +1,136 @@
+const svgtofont = require('svgtofont').default;
+const path = require('path');
+const fs = require('fs');
+const { optimize } = require('svgo');
+const Case = require('case');
+
+const rootDir = path.resolve(__dirname, '..');
+const srcDir = path.resolve(rootDir, 'svg');
+const distDir = path.resolve(rootDir, 'dist');
+const vueDir = path.resolve(distDir, 'vue');
+const uniappDir = path.resolve(distDir, 'uniapp');
+const uniappCompDir = path.resolve(distDir, 'uniapp-components');
+const uniappImgDir = path.resolve(uniappDir, 'images');
+
+// Ensure directories exist
+[distDir, vueDir, uniappDir, uniappCompDir, uniappImgDir].forEach(dir => {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+});
+
+function isMultiColor(svgContent) {
+  const colorRegex = /(fill|stroke)="(?!none|currentColor|\$)(#[0-9a-fA-F]{3,6}|rgba?|hsla?)/gi;
+  const matches = svgContent.match(colorRegex);
+  if (!matches) return false;
+  const colors = new Set(matches.map(m => m.split('"')[1].toLowerCase()));
+  return colors.size > 1;
+}
+
+async function build() {
+  const files = fs.readdirSync(srcDir).filter(f => f.endsWith('.svg'));
+  const singleColorIcons = [];
+  const multiColorIcons = [];
+  const iconData = [];
+  const svgMappings = {};
+
+  console.log(`Building icons from ${srcDir} to ${distDir}...`);
+
+  for (const file of files) {
+    const name = file.replace('.svg', '');
+    const pascalName = Case.pascal(name);
+    const content = fs.readFileSync(path.join(srcDir, file), 'utf-8');
+    
+    const multi = isMultiColor(content);
+    
+    // Optimize
+    const svgoPlugins = ['preset-default', 'removeDimensions'];
+    if (!multi) {
+      svgoPlugins.push({
+        name: 'convertColors',
+        params: { currentColor: true }
+      });
+    }
+
+    let optimized = optimize(content, { 
+      path: file,
+      plugins: svgoPlugins
+    }).data;
+
+    const innerSvg = optimized.replace(/<svg[^>]*>|<\/svg>/g, '');
+
+    // 1. Generate Standard Vue Component (PC/Web)
+    const vueContent = `<template>
+  <svg 
+    viewBox="0 0 24 24" 
+    :width="size" 
+    :height="size" 
+    :fill="multi ? 'none' : color"
+    xmlns="http://www.w3.org/2000/svg"
+    v-bind="$attrs"
+  >
+    ${innerSvg}
+  </svg>
+</template>
+
+<script setup>
+defineProps({
+  size: { type: [String, Number], default: '1em' },
+  color: { type: String, default: 'currentColor' },
+  multi: { type: Boolean, default: ${multi} }
+});
+</script>`;
+    fs.writeFileSync(path.join(vueDir, `${pascalName}.vue`), vueContent);
+
+    // 2. Optimized Standalone SVG for Native/MP
+    if (multi) {
+      multiColorIcons.push(name);
+      // Include multi-color SVG data inline in icons-svg.js
+      // This avoids the need for dynamic imports which don't work with bare module specifiers
+      svgMappings[name] = { inner: innerSvg, multi: true };
+      
+      fs.writeFileSync(path.join(uniappImgDir, file), optimized);
+    } else {
+      singleColorIcons.push(file);
+    }
+
+    iconData.push({ name, pascalName, multi });
+  }
+
+  // 3. Generate Vue Entry
+  const entryContent = iconData.map(i => `export { default as Icon${i.pascalName} } from './vue/${i.pascalName}.vue';`).join('\n');
+  fs.writeFileSync(path.join(distDir, 'index.js'), entryContent);
+
+  // 4. Build Native Font (UniApp Native Single-color)
+  let fontMappings = {};
+  if (singleColorIcons.length > 0) {
+    const tempFontSrc = path.join(rootDir, 'temp-font-src');
+    if (!fs.existsSync(tempFontSrc)) fs.mkdirSync(tempFontSrc);
+    singleColorIcons.forEach(f => fs.copyFileSync(path.join(srcDir, f), path.join(tempFontSrc, f)));
+
+    await svgtofont({
+      src: tempFontSrc,
+      dist: uniappDir,
+      fontName: 'upicon-custom',
+      css: false,
+      outSVGReact: false,
+      outSVGPath: false,
+      typescript: true,
+      emptyDist: false,
+      getIconUnicode: (name, unicode) => {
+        fontMappings[name] = unicode;
+      }
+    });
+    fs.rmSync(tempFontSrc, { recursive: true, force: true });
+    console.log('Native font generated.');
+  }
+
+  // 5. Generate Mappings for consumers
+  fs.writeFileSync(path.join(uniappDir, 'icons-svg.js'), `export default ${JSON.stringify(svgMappings, null, 2)}`);
+  fs.writeFileSync(path.join(uniappDir, 'icons-generated.js'), `export default ${JSON.stringify(fontMappings, null, 2)}`);
+  fs.writeFileSync(path.join(uniappDir, 'icons-generated.uts'), `export default ${JSON.stringify(fontMappings, null, 2)} as UTSJSONObject`);
+  fs.writeFileSync(path.join(uniappDir, 'icons-custom.json'), JSON.stringify(iconData.map(i => i.name), null, 2));
+  fs.writeFileSync(path.join(uniappDir, 'icons-multicolor.json'), JSON.stringify(multiColorIcons, null, 2));
+
+  console.log('All icons built to dist successfully.');
+}
+
+build().catch(console.error);

package/scripts/install.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Install phillui-icons into uni_modules for UniApp projects.
+ * - Detects project root (INIT_CWD preferred) and whether 'src' exists.
+ * - Copies this package's dist assets into <project>/(src/)?uni_modules/phillui-icons/dist
+ */
+
+function resolvePackageRoot() {
+  // When executed from node_modules: __dirname -> <pkg>/scripts
+  // In workspace/dev: __dirname -> repo/packages/core/icons/scripts
+  const scriptsDir = __dirname;
+  const candidate = path.resolve(scriptsDir, '..'); // <pkg>
+  if (fs.existsSync(path.join(candidate, 'dist'))) return candidate;
+  const alt = path.resolve(scriptsDir, '../..'); // in case of different layouts
+  if (fs.existsSync(path.join(alt, 'dist'))) return alt;
+  throw new Error('Cannot locate phillui-icons package root (dist not found).');
+}
+
+function copyDir(src, dest, exclude = []) {
+  if (!fs.existsSync(src)) return;
+  if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src)) {
+    if (exclude.some(pattern => {
+      if (pattern.startsWith('*.')) return entry.endsWith(pattern.slice(1));
+      return entry === pattern;
+    })) continue;
+
+    const s = path.join(src, entry);
+    const d = path.join(dest, entry);
+    const stat = fs.lstatSync(s);
+    if (stat.isDirectory()) {
+      copyDir(s, d, exclude);
+    } else if (stat.isSymbolicLink()) {
+      const real = fs.realpathSync(s);
+      const realStat = fs.statSync(real);
+      if (realStat.isDirectory()) {
+        copyDir(real, d, exclude);
+      } else {
+        fs.copyFileSync(real, d);
+      }
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function rimraf(p) {
+  if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true });
+}
+
+function main() {
+  const projectRoot = process.env.INIT_CWD || process.cwd();
+  const srcDir = path.join(projectRoot, 'src');
+  const uniModulesBase = fs.existsSync(srcDir)
+    ? path.join(srcDir, 'uni_modules')
+    : path.join(projectRoot, 'uni_modules');
+  const targetPkgDir = path.join(uniModulesBase, 'phillui-icons');
+  const targetDistDir = path.join(targetPkgDir, 'dist');
+
+  const pkgRoot = resolvePackageRoot();
+  const sourceDistDir = path.join(pkgRoot, 'dist');
+
+  const isX = fs.existsSync(path.join(projectRoot, 'App.uvue')) || fs.existsSync(path.join(srcDir, 'App.uvue'));
+  const exclude = isX ? [] : ['*.uvue', '*.uts'];
+
+  try {
+    if (!fs.existsSync(uniModulesBase)) fs.mkdirSync(uniModulesBase, { recursive: true });
+    // Clean old content
+    rimraf(targetPkgDir);
+    fs.mkdirSync(targetPkgDir, { recursive: true });
+    // Only copy dist (uniapp and vue build outputs)
+    copyDir(sourceDistDir, targetDistDir, exclude);
+    // Lightweight package.json for uni_modules (optional but helps tooling)
+    const lightPkgJson = {
+      name: 'phillui-icons',
+      description: 'Icons assets for phillUI in UniApp uni_modules',
+    };
+    fs.writeFileSync(path.join(targetPkgDir, 'package.json'), JSON.stringify(lightPkgJson, null, 2));
+    console.log(`[phillui/icons] Installed to ${targetDistDir} ${isX ? '(UniApp X)' : '(UniApp, Exclude .uvue/.uts)'}`);
+
+    // Simplified: No longer patching vite.config as we use relative paths
+    // patchViteAlias(projectRoot, !!fs.existsSync(srcDir));
+  } catch (e) {
+    console.error('[phillui/icons] Installation failed:', e.message);
+    process.exit(1);
+  }
+}
+
+function patchViteAlias(projectRoot, hasSrc) {
+  const candidates = ['vite.config.ts', 'vite.config.js'].map(f => path.join(projectRoot, f));
+  const vitePath = candidates.find(p => fs.existsSync(p));
+  if (!vitePath) return;
+  try {
+    let code = fs.readFileSync(vitePath, 'utf8');
+    if (code.includes('/* phillui-icons-alias */') || code.includes('phillui-icons')) {
+      return; // already patched
+    }
+    const replacementPath = hasSrc ? 'path.resolve(__dirname, \'src/uni_modules/phillui-icons\')'
+                                   : 'path.resolve(__dirname, \'uni_modules/phillui-icons\')';
+    // Ensure path import
+    if (!/import\s+path\s+from\s+['"]path['"]/.test(code)) {
+      code = code.replace(/import\s+uni\s+from\s+['"]@dcloudio\/vite-plugin-uni['"]\s*;?/, (m) => `${m}\nimport path from "path";`);
+    }
+    // Insert alias entry
+    if (/alias\s*:\s*\[/.test(code)) {
+      code = code.replace(/alias\s*:\s*\[/, (m) => `${m}\n        /* phillui-icons-alias */ { find: /phillui-icons/, replacement: ${replacementPath} },`);
+    } else if (/resolve\s*:\s*\{/.test(code)) {
+      code = code.replace(/resolve\s*:\s*\{/, (m) => `${m}\n      alias: [\n        /* phillui-icons-alias */ { find: /phillui-icons/, replacement: ${replacementPath} }\n      ],`);
+    } else {
+      // Fallback: inject a resolve block after plugins
+      code = code.replace(/plugins\s*:\s*\[[\s\S]*?\],/, (m) => `${m}\n    resolve: {\n      alias: [\n        /* phillui-icons-alias */ { find: /phillui-icons/, replacement: ${replacementPath} }\n      ]\n    },`);
+    }
+    fs.writeFileSync(vitePath, code, 'utf8');
+    console.log('[phillui/icons] Patched Vite alias for phillui-icons.');
+  } catch (e) {
+    console.warn('[phillui/icons] Skip patching Vite alias:', e.message);
+  }
+}
+
+main();