@fangzhongya/icons 0.0.8 → 0.0.9

package/dist/vite/index.js

@@ -1,10 +1,928 @@
 import "../chunk-MLKGABMK.js";
 
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-4CBOJSDB.js
+function getStartSames(str, val) {
+  let s = "";
+  const vs = [...val];
+  let index = 0;
+  for (; index < vs.length; index++) {
+    const element = vs[index];
+    if (element === str.charAt(index)) {
+      s += element;
+    } else {
+      break;
+    }
+  }
+  return [s, str.substring(index), val.substring(index)];
+}
+function getImportUrl(url, imp) {
+  const arr = getStartSames(url, imp);
+  const ts = arr[0];
+  if (!/[\\|\/]$/.test(ts)) {
+    const regs = ts.match(/[\\|\/]([^\\|\/]*)$/);
+    if (regs && regs.length > 0) {
+      const a = regs[1];
+      arr[0] = ts.substring(0, regs.index + 1);
+      arr[1] = a + arr[1];
+      arr[2] = a + arr[2];
+    }
+  }
+  const l = arr[1].split(/\\|\//).length - 1;
+  let ds = ["./"];
+  if (l > 0) {
+    ds = [];
+    for (let index = 0; index < l; index++) {
+      ds.push("../");
+    }
+  }
+  return ds.join("") + arr[2].replace(/\\/g, "/");
+}
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-3GUX6LOY.js
+function getImportUrlSuffix(url, imp) {
+  return getImportUrl(url, imp).replace(/\.([a-z|A-Z][a-z|A-Z|0-9]*)$/, "");
+}
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-I5KYQX4M.js
+import {
+  open,
+  readdir,
+  stat,
+  writeFile,
+  write,
+  mkdir,
+  readFile,
+  createReadStream,
+  access,
+  constants
+} from "fs";
+import { join } from "path";
+function getUrlCatalogueObj(str) {
+  const reg = /(\\|\/)([^\\|\/]+)\.([a-z|A-Z][a-z|A-Z|0-9]*)$/g;
+  const ml = str.replace(reg, "");
+  let name = "";
+  let suffix = "";
+  let apart = "";
+  const arr = reg.exec(str);
+  if (arr) {
+    apart = arr[1];
+    name = arr[2];
+    suffix = arr[3];
+  }
+  return {
+    catalogue: ml,
+    name,
+    suffix,
+    apart
+  };
+}
+function getNewFileName(url) {
+  const obj = getUrlCatalogueObj(url);
+  let wb = obj.name;
+  if (wb) {
+    const reg = /([0-9]+)$/g;
+    const regs = reg.exec(wb);
+    if (regs && regs.length > 0) {
+      const sl = Number(regs[1]) + 1;
+      const reg1 = new RegExp(regs[1] + "$");
+      wb = wb.replace(reg1, (sl + "").padStart(regs[1].length, "0"));
+    } else {
+      wb = wb + "1";
+    }
+    return obj.catalogue + obj.apart + wb + "." + obj.suffix;
+  } else {
+    return "";
+  }
+}
+function fsReadFile(url, type) {
+  if (!type || type === true) {
+    type = "utf-8";
+  }
+  return new Promise((resolve3, reject) => {
+    readFile(url, type, (err, dataStr) => {
+      if (err) {
+        console.log("2", err);
+        reject("");
+      } else {
+        resolve3(dataStr);
+      }
+    });
+  });
+}
+function fsCreateReadStream(url, type) {
+  if (!type || type === true) {
+    type = "utf-8";
+  }
+  return new Promise((resolve3) => {
+    const stream = createReadStream(url, {
+      start: 0,
+      end: 100,
+      encoding: type
+    });
+    let st = "";
+    stream.on("data", (data) => {
+      st += data;
+    });
+    stream.on("end", () => {
+      resolve3(st);
+    });
+    stream.on("error", () => {
+      resolve3("");
+    });
+  });
+}
+function fsAccess(reaPath) {
+  return new Promise((resolve3) => {
+    try {
+      access(reaPath, constants.F_OK, (err) => {
+        if (err) {
+          resolve3(false);
+        } else {
+          resolve3(true);
+        }
+      });
+    } catch (e) {
+      resolve3(false);
+    }
+  });
+}
+function fsReaddir(filePath) {
+  return new Promise((resolve3, reject) => {
+    readdir(filePath, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        const lg = files.length;
+        const dirs = [];
+        const file = [];
+        if (lg) {
+          let i = 0;
+          files.forEach((filename) => {
+            const filedir = join(filePath, filename);
+            stat(filedir, (err2, stats) => {
+              i++;
+              if (err2) {
+                console.log("4", err2);
+              } else {
+                const isFile = stats.isFile();
+                const isDir = stats.isDirectory();
+                if (isFile) {
+                  file.push(filename);
+                }
+                if (isDir) {
+                  dirs.push(filename);
+                }
+              }
+              if (i >= lg) {
+                resolve3({
+                  file,
+                  dirs
+                });
+              }
+            });
+          });
+        } else {
+          resolve3({
+            file,
+            dirs
+          });
+        }
+      }
+    });
+  });
+}
+function fsOpenStream(path, json, type = 0, cover, callback) {
+  open(path, "wx", async (err, fd) => {
+    if (err) {
+      if (err.code === "EEXIST") {
+        if (type == 1 || type == 0) {
+          const fwrite = () => {
+            writeFile(path, json, "utf-8", (err2) => {
+              if (err2) {
+                console.log("6", err2);
+                if (callback) {
+                  callback(path, cover ? 3 : 2, false, type);
+                }
+              } else {
+                if (callback) {
+                  callback(path, cover ? 3 : 2, true, type);
+                }
+              }
+            });
+          };
+          if (cover) {
+            const st = await fsCreateReadStream(path);
+            if (!st.includes("@config cover=true")) {
+              fwrite();
+            } else {
+              if (callback) callback(path, 3, false, type);
+            }
+          } else {
+            fwrite();
+          }
+        } else if (type == 3) {
+          path = getNewFileName(path);
+          if (path) {
+            fsOpenStream(path, json, type, cover, callback);
+          } else {
+            if (callback) {
+              callback(path, 3, false, type);
+            }
+          }
+        } else {
+          if (callback) {
+            callback(path, 2, false, type);
+          }
+        }
+      } else {
+        if (callback) {
+          callback(path, 0, false, type);
+        }
+      }
+    } else {
+      if (type != 1) {
+        write(fd, json, (err2) => {
+          if (err2) {
+            console.log("8", err2);
+            if (callback) {
+              callback(path, 1, false, type);
+            }
+          } else {
+            if (callback) {
+              callback(path, 1, true, type);
+            }
+          }
+        });
+      } else {
+        if (callback) {
+          callback(path, 1, false, type);
+        }
+      }
+    }
+  });
+}
+function fsMkdir(reaPath, callback) {
+  mkdir(reaPath, { recursive: true }, (err, path) => {
+    if (err) {
+      console.log("0", err);
+      if (callback) {
+        callback(reaPath, false);
+      }
+    } else {
+      if (callback) {
+        callback(reaPath, true, path);
+      }
+    }
+  });
+}
+function writeInit(url, callback, isDirs, isFile, issynch) {
+  return new Promise(async (resolve3) => {
+    if (url) {
+      const data = await fsReaddir(url);
+      const arr = await writeFileUrl(
+        url,
+        data,
+        callback,
+        isDirs,
+        isFile,
+        issynch
+      );
+      resolve3(arr);
+    } else {
+      resolve3([]);
+    }
+  });
+}
+function writeFileUrl(url, files, callback, isDirs, isFile, issynch) {
+  return new Promise(async (resolve3) => {
+    const arr = [];
+    const dirs = [];
+    if (files.dirs.length > 0) {
+      for (let i = 0; i < files.dirs.length; i++) {
+        const dir = files.dirs[i];
+        let is = true;
+        if (isDirs) {
+          is = isDirs(url, dir);
+        }
+        if (is) {
+          dirs.push(dir);
+          const urls = await writeInit(
+            join(url, dir),
+            callback,
+            isDirs,
+            isFile,
+            issynch
+          );
+          arr.push(...urls);
+        }
+      }
+    }
+    files.dirs = dirs;
+    const file = [];
+    if (files.file.length > 0) {
+      files.file.forEach((name) => {
+        let is = true;
+        if (isFile) {
+          is = isFile(url, name);
+        }
+        if (is) {
+          file.push(name);
+          arr.push(join(url, name));
+        }
+      });
+    }
+    files.file = file;
+    if (callback) {
+      if (issynch) {
+        await callback(url, files, arr);
+      } else {
+        callback(url, files, arr);
+      }
+    }
+    resolve3(arr);
+  });
+}
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-FWEGYLR7.js
+import { resolve, join as join2 } from "path";
+function styleLog(msg = "", obj) {
+  const arr = ["\x1B[0m"];
+  if (obj == null ? void 0 : obj.revert) {
+    arr.push("\x1B[4m");
+  }
+  if (obj == null ? void 0 : obj.lineThrough) {
+    arr.push("\x1B[9m");
+  }
+  if (obj == null ? void 0 : obj.italic) {
+    arr.push("\x1B[3m");
+  }
+  if (obj == null ? void 0 : obj.bold) {
+    arr.push("\x1B[1m");
+  }
+  if (obj == null ? void 0 : obj.bag) {
+    arr.push(`\x1B[4${obj == null ? void 0 : obj.bag}m`);
+  } else {
+    arr.push("\x1B[40m");
+  }
+  if (obj == null ? void 0 : obj.text) {
+    arr.push(`\x1B[3${obj == null ? void 0 : obj.text}m`);
+  } else {
+    arr.push("\x1B[30m");
+  }
+  arr.push(msg);
+  arr.push("\x1B[0m");
+  return arr.join("");
+}
+function getSuffix(url) {
+  const reg = /\.([a-z|A-Z][a-z|A-Z|0-9]*)$/;
+  const regs = reg.exec(url);
+  if (regs && regs.length > 0) {
+    return regs[1];
+  }
+  return "";
+}
+function matchsEnd(key, matchs) {
+  if (matchs && matchs.length > 0) {
+    for (const value of matchs) {
+      if (typeof value == "string") {
+        if (key.endsWith(value)) {
+          return true;
+        }
+      } else {
+        if (value.test(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } else {
+    return true;
+  }
+}
+function matchsStart(key, matchs) {
+  if (matchs && matchs.length > 0) {
+    for (const value of matchs) {
+      if (typeof value == "string") {
+        if (key.startsWith(value)) {
+          return true;
+        }
+      } else {
+        if (value.test(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } else {
+    return true;
+  }
+}
+function getUrlCatalogue(str) {
+  const reg = /((\\|\/)([^\\|\/]+)(\.[a-z|A-Z][a-z|A-Z|0-9]*))?$/g;
+  return str.replace(reg, "");
+}
+var defaultSuffixReg = /\\.[a-z|A-Z]+$/;
+var defaultConfig = {
+  name: "com",
+  /**
+   * 打包的文件地址
+   */
+  dir: "./packages/",
+  /**
+   * 文件后缀
+   */
+  extensions: ["js", "ts"],
+  suffixReg: defaultSuffixReg,
+  fileTongre: false,
+  /**
+   * 是否替换文件
+   */
+  fileCover: false,
+  /**
+   * 判断当前文件100个字节内存在 @config cover=true 就不写入
+   */
+  coverConfig: false,
+  /**
+   * 写入注释
+   */
+  writeNotes: false,
+  /**
+   * 读取当前文件，文件的编码类型，默认utf-8
+   */
+  read: false,
+  /**
+   * 匹配目录数组
+   * 从头开始匹配
+   */
+  matchs: [],
+  /**
+   * 匹配文件路径
+   * 从尾部开始匹配
+   */
+  matchexts: [],
+  forceUpdate: [],
+  /**
+   * 不匹配目录数组
+   * 从头开始匹配
+   */
+  nomatchs: [],
+  /**
+   * 不匹配文件路径
+   * 从尾部开始匹配
+   */
+  nomatchexts: [],
+  issort: false,
+  issynch: false
+};
+function getSuffixReg(ex = []) {
+  if (ex.length == 0) {
+    return defaultSuffixReg;
+  }
+  return new RegExp(`\\.(${ex.join("|")})$`);
+}
+var FangCom = class {
+  _configCallback;
+  _defaultConfig;
+  config;
+  constructor(config, callback) {
+    this.config = {};
+    this._configCallback = callback;
+    this._defaultConfig = defaultConfig;
+    this.initConfig(config);
+  }
+  async runDev(callback, configCallback, config, nosort) {
+    this.initConfig(config);
+    const call = configCallback || this._configCallback;
+    if (call) {
+      const c = call(this.config);
+      if (c) {
+        this.initConfig(c);
+      }
+    }
+    return await this.handle(callback, nosort);
+  }
+  /**
+   * 初始化
+   * @param config
+   * @returns
+   */
+  initConfig(config) {
+    if (config) {
+      this.config = config;
+      this.setDefaultConfig();
+      this.config.suffixReg = getSuffixReg(this.config.extensions);
+      if (!this.config.matchexts || this.config.matchexts.length == 0) {
+        this.config.matchexts = [this.config.suffixReg];
+      }
+    }
+    return this.config;
+  }
+  setDefaultConfig() {
+    Object.keys(this._defaultConfig).forEach((key) => {
+      if (typeof this.config[key] == "undefined") {
+        this.config[key] = this._defaultConfig[key];
+      }
+    });
+  }
+  getFileName(name) {
+    if (this.config.suffixReg) {
+      return name.replace(this.config.suffixReg, "");
+    } else {
+      return name.replace(defaultSuffixReg, "");
+    }
+  }
+  /**
+   * 获取当前位置
+   * @param dir
+   * @returns
+   */
+  getDirUrl(dir) {
+    const str = dir || this.config.dir;
+    if (str) {
+      return resolve(process.cwd(), str);
+    } else {
+      return "";
+    }
+  }
+  isForceUpdate(url) {
+    if (this.config.forceUpdate && this.config.forceUpdate.length > 0) {
+      return matchsEnd(url.replace(/\\/g, "/"), this.config.forceUpdate);
+    } else {
+      return false;
+    }
+  }
+  isMatchFile(url, name) {
+    const dirUrl = this.getDirUrl();
+    const dir = join2(url, name).replace(dirUrl, "").replace(/\\/g, "/");
+    const is = matchsEnd(dir, this.config.matchexts);
+    const nomatchexts = this.config.nomatchexts;
+    if (is && nomatchexts && nomatchexts.length > 0) {
+      if (matchsEnd(dir, nomatchexts)) {
+        return false;
+      } else {
+        return true;
+      }
+    } else {
+      return is;
+    }
+  }
+  isMatchDir(url, name) {
+    const dirUrl = this.getDirUrl();
+    const dir = join2(url, name).replace(dirUrl, "").replace(/\\/g, "/");
+    const is = matchsStart(dir, this.config.matchs);
+    const nomatchs = this.config.nomatchs;
+    if (is && nomatchs && nomatchs.length > 0) {
+      if (matchsStart(dir, nomatchs)) {
+        return false;
+      } else {
+        return true;
+      }
+    } else {
+      return is;
+    }
+  }
+  /**
+   * 处理方法
+   * @param callback
+   */
+  handle(callback, nosort) {
+    return new Promise(async (resolve22) => {
+      const url = this.getDirUrl();
+      if (url) {
+        const rarr = await writeInit(
+          url,
+          async (...arr) => {
+            if (callback) {
+              await callback(...arr);
+            }
+            return await this.writeCallback(...arr, nosort);
+          },
+          (...arr) => {
+            return this.isMatchDir(...arr);
+          },
+          (...arr) => {
+            return this.isMatchFile(...arr);
+          },
+          this.config.issynch
+        );
+        resolve22(rarr);
+      } else {
+        resolve22([]);
+      }
+    });
+  }
+  getFileNotes(url) {
+    const suffix = getSuffix(url);
+    const sz = [
+      `@config cover=false`,
+      `cover \u662F\u5426\u8986\u76D6\u5F53\u524D\u6587\u4EF6\uFF0C\u9ED8\u8BA4\u662Ffalse\uFF0C true \u8868\u793A\u4E0D\u8986\u76D6`,
+      `\u5F53\u524D\u5DF2\u7ECF\u7531@fangzhongya/create\u81EA\u52A8\u751F\u6210`,
+      `${(/* @__PURE__ */ new Date()).toString()}`
+    ];
+    const hy = ["md", "html", "vue"];
+    if (hy.includes(suffix)) {
+      const arr = ["<!--"];
+      sz.forEach((v) => {
+        arr.push(" - " + v);
+      });
+      arr.push("-->");
+      return arr;
+    } else {
+      const arr = ["/**"];
+      sz.forEach((v) => {
+        arr.push(" * " + v);
+      });
+      arr.push(" */");
+      return arr;
+    }
+  }
+  /**
+   * 输出文件，判断目录是否存在
+   * @param url
+   * @param sts
+   */
+  fileOpen(url, sts, fileUrls, type) {
+    fsMkdir(getUrlCatalogue(url), (reaPath, is, ml) => {
+      const logs = this.getLogs();
+      logs.push(styleLog("dir", {}));
+      if (is) {
+        if (ml) {
+          logs.push(
+            styleLog("add", {
+              text: 2,
+              italic: true
+            })
+          );
+          logs.push(
+            styleLog(reaPath, {
+              text: 2,
+              revert: true
+            })
+          );
+          console.log(logs.join(" "));
+        }
+      } else {
+        logs.push(
+          styleLog(reaPath, {
+            text: 1,
+            revert: true
+          })
+        );
+        console.log(logs.join(" "));
+      }
+      this.setOpen(url, sts, type, (kurl, _type, is2, _tn) => {
+        if (is2 && fileUrls) {
+          fileUrls.push(kurl);
+        }
+      });
+    });
+  }
+  /**
+   * 输出文件
+   * @param url
+   * @param str
+   * @param callback
+   */
+  setOpen(url, str, type, callback) {
+    let tn = this.config.fileTongre ? 3 : 2;
+    if (this.config.fileCover) {
+      tn = 0;
+    }
+    if (tn == 2) {
+      if (this.isForceUpdate(url)) {
+        tn = 0;
+      }
+    }
+    if (typeof type != "undefined") {
+      tn = type;
+    }
+    if (this.config.writeNotes && !/\.json$/.test(url)) {
+      str = this.getFileNotes(url).join("\n") + "\n" + str;
+    }
+    fsOpenStream(
+      url,
+      str,
+      tn,
+      this.config.coverConfig,
+      (kurl, type2, is) => {
+        if (!(tn == 2 && type2 == 2)) {
+          const logs = this.getLogs();
+          logs.push(styleLog("file", {}));
+          if (type2 == 1) {
+            logs.push(
+              styleLog("add", {
+                text: 2,
+                italic: true
+              })
+            );
+          } else if (type2 == 2) {
+            logs.push(
+              styleLog("update", {
+                italic: true,
+                text: 4
+              })
+            );
+          }
+          if (is) {
+            logs.push(
+              styleLog(kurl, {
+                text: 2,
+                revert: true
+              })
+            );
+          } else {
+            logs.push(
+              styleLog(kurl, {
+                text: 1,
+                revert: true
+              })
+            );
+          }
+          console.log(logs.join(" "));
+        }
+        if (callback) {
+          callback(kurl, type2, is, tn);
+        }
+      }
+    );
+  }
+  /**
+   * 获取日志头
+   */
+  getLogs() {
+    const logs = [];
+    logs.push(
+      styleLog("[@fangzhongya/create]", {
+        text: 3
+      })
+    );
+    logs.push(
+      styleLog(this._defaultConfig.name, {
+        text: 4
+      })
+    );
+    return logs;
+  }
+};
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-IMEZSVK5.js
+import { resolve as resolve2, join as join3 } from "path";
+var defaultConfig2 = Object.assign({}, defaultConfig, {
+  name: "file",
+  /**
+   * 生成的文件名称
+   */
+  gene: void 0,
+  /**
+   * 文件生成方法
+   */
+  fileSet: void 0
+});
+var FangFile = class extends FangCom {
+  constructor(config, callback) {
+    super();
+    this.config = {};
+    this._configCallback = callback;
+    this._defaultConfig = defaultConfig2;
+    this.initConfig(config || this.config);
+  }
+  getDefaultGene(name, url, _wj) {
+    return join3(url, name);
+  }
+  getDefaultFileSet(_name, _url, _text, _wjm, _imp, _surl) {
+    return [];
+  }
+  getGeneObj(url, name, outDir) {
+    return getUrlCatalogueObj(
+      join3(
+        resolve2(process.cwd(), outDir),
+        join3(url, name).replace(this.getDirUrl(), "")
+      )
+    );
+  }
+  /**
+   * 获取输出地址方法
+   * @param gene
+   * @returns
+   */
+  getGene(gene) {
+    gene = gene || this.config.gene;
+    if (!gene) {
+      return (...arr) => {
+        return this.getDefaultGene(...arr);
+      };
+    } else {
+      return gene;
+    }
+  }
+  fileRead(url, type) {
+    return new Promise((resolve22) => {
+      fsAccess(url).then(() => {
+        resolve22(fsReadFile(url, type));
+      });
+    });
+  }
+  getFileSet(fileSet) {
+    fileSet = fileSet || this.config.fileSet;
+    if (!fileSet) {
+      return (...arr) => {
+        return this.getDefaultFileSet(...arr);
+      };
+    } else {
+      return fileSet;
+    }
+  }
+  /**
+   * 回调方法
+   * @param url
+   * @param file
+   * @param urls
+   */
+  async writeCallback(url, readdir2, fileUrls) {
+    const gene = this.getGene();
+    const fileSet = this.getFileSet();
+    const read = this.config.read;
+    if (readdir2.file) {
+      for (let i = 0; i < readdir2.file.length; i++) {
+        const name = readdir2.file[i];
+        const furl = join3(url, name);
+        const wjmc = this.getFileName(name);
+        const gu = gene(name, url, wjmc);
+        const imp = getImportUrlSuffix(gu, furl);
+        const arr = [];
+        if (fileSet) {
+          let text = "";
+          if (read) {
+            text = await fsReadFile(furl, read);
+          }
+          arr.push(...fileSet(name, url, text, wjmc, imp, gu));
+        }
+        if (arr.length > 0) {
+          this.fileOpen(gu, arr.join("\n"), fileUrls);
+        }
+      }
+    }
+    return true;
+  }
+};
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-3VPCYJWK.js
+import { join as join4 } from "path";
+var defaultConfig22 = Object.assign({}, defaultConfig2, {
+  name: "out",
+  outDir: "./",
+  isNeader: true
+});
+var FangOut = class extends FangFile {
+  constructor(config, callback) {
+    super();
+    this.config = {};
+    this._configCallback = callback;
+    this._defaultConfig = defaultConfig22;
+    this.initConfig(config || this.config);
+  }
+  getFileNeader(name, url) {
+    return [`/**`, ` * ${join4(url, name).replace(/\\/g, "/")}`, " */"];
+  }
+  /**
+   * 获取输出地址方法
+   * @param gene
+   * @returns
+   */
+  getDefaultGene(name, url, _wj) {
+    const obj = this.getGeneObj(url, name, this.config.outDir);
+    return join4(obj.catalogue, obj.name + "." + obj.suffix);
+  }
+  getDefaultFileSet(name, url, text, _wjm, _imp) {
+    const arr = [text];
+    if (this.config.isNeader) {
+      return [...this.getFileNeader(name, url), ...arr];
+    }
+    return arr;
+  }
+};
+function runDev(config, configCallback, callback) {
+  const fang = new FangOut(config);
+  fang.runDev(callback, configCallback);
+}
+
 // packages/vite/index.ts
 var virtualModuleId = "virtual:fang-icon";
 function simpleFangIcon(options = {}) {
   const { type = "svg", directory = "./svg" } = options;
   const resolvedVirtualModuleId = "\0" + virtualModuleId;
+  if (type === "pub" && options.mobile) {
+    console.log("runDev");
+    runDev({
+      issort: true,
+      dir: "./node_modules/@fangzhongya/icons/dist/svg",
+      outDir: directory,
+      extensions: ["svg"],
+      read: true,
+      fileCover: true,
+      isNeader: false
+    });
+  }
   return {
     name: "simple-fang-icon",
     resolveId(id) {
@@ -16,14 +934,12 @@ function simpleFangIcon(options = {}) {
     load(id) {
       if (id === resolvedVirtualModuleId) {
         return `
-import { defineComponent, h, shallowRef, resolveComponent, watchEffect } from 'vue'
+import { defineComponent, h,} from 'vue'
 import FangIcon from '@fangzhongya/icons/icon/index'
-
 export default defineComponent({
   props: {
     name: {
       type: [String, Object],
-      required: true
     },
     type: {
       type: String,
@@ -35,39 +951,11 @@ export default defineComponent({
     }
   },
   setup(props, { attrs }) {
-     const component = shallowRef(null);
-    
-    watchEffect(async () => {
-      const iconName = props.name;
-      
-      if (typeof iconName === 'string' && props.type === 'svg') {
-        try {
-          // \u65B9\u68481\uFF1A\u4F7F\u7528\u52A8\u6001\u5BFC\u5165\u4F46\u52A0\u4E0A vite-ignore \u6CE8\u91CA
-          const module = await import(/* @vite-ignore */ '@fangzhongya/icons/vue/' + iconName);
-          component.value = module.default;
-        } catch (error) {
-          console.warn('Failed to load icon:', iconName, error);
-          // \u5982\u679C\u5BFC\u5165\u5931\u8D25\uFF0C\u5C1D\u8BD5\u89E3\u6790\u7EC4\u4EF6
-          const resolved = resolveComponent(iconName);
-          if (resolved) {
-            component.value = resolved;
-          } else {
-            // \u5982\u679C\u7EC4\u4EF6\u4E0D\u5B58\u5728\uFF0C\u8FD4\u56DE\u5360\u4F4D\u7B26
-            component.value = {
-              setup: () => () => h('span', { class: 'icon-error' }, \`Icon \${iconName} not found\`)
-            };
-          }
-        }
-      } else {
-        component.value = iconName;
-      }
-    });
-    
     return () => {
       return h(FangIcon, {
         ...attrs,
         type: props.type,
-        name: component.value,
+        name: props.name,
         directory: props.directory
       });
     };