@fangzhongya/vue-components 0.1.20 → 0.1.23

package/dist/chunk-SDVC6K2I.js

@@ -0,0 +1,1237 @@
+import {
+  styleLog
+} from "./chunk-3XFEJIQP.js";
+
+// packages/imports.ts
+import { join as join4 } from "path";
+
+// node_modules/.pnpm/@fangzhongya+utils@0.0.75/node_modules/@fangzhongya/utils/dist/chunk-FS4JPT23.js
+function deComment(code) {
+  let output = "";
+  let state = "code";
+  let escaping = false;
+  let i = 0;
+  const len = code.length;
+  while (i < len) {
+    const char = code[i];
+    const nextChar = code[i + 1];
+    switch (state) {
+      case "code":
+        if (char === "/" && nextChar === "/") {
+          state = "singleLine";
+          i += 2;
+        } else if (char === "/" && nextChar === "*") {
+          state = "multiLine";
+          i += 2;
+        } else if (char === "'") {
+          state = "singleQuote";
+          output += char;
+          i++;
+        } else if (char === '"') {
+          state = "doubleQuote";
+          output += char;
+          i++;
+        } else if (char === "`") {
+          state = "template";
+          output += char;
+          i++;
+        } else {
+          output += char;
+          i++;
+        }
+        break;
+      case "singleLine":
+        if (char === "\n" || char === "\r") {
+          state = "code";
+          output += char;
+          i++;
+          if (char === "\r" && nextChar === "\n") {
+            output += nextChar;
+            i++;
+          }
+        } else {
+          i++;
+        }
+        break;
+      case "multiLine":
+        if (char === "*" && nextChar === "/") {
+          state = "code";
+          i += 2;
+          if (output.length > 0 && /[a-zA-Z0-9_$]$/.test(output) && i < len && /[a-zA-Z0-9_$]/.test(code[i])) {
+            output += " ";
+          }
+        } else {
+          i++;
+        }
+        break;
+      case "singleQuote":
+        output += char;
+        if (!escaping && char === "'") {
+          state = "code";
+        }
+        escaping = !escaping && char === "\\";
+        i++;
+        break;
+      case "doubleQuote":
+        output += char;
+        if (!escaping && char === '"') {
+          state = "code";
+        }
+        escaping = !escaping && char === "\\";
+        i++;
+        break;
+      case "template":
+        output += char;
+        if (!escaping && char === "`") {
+          state = "code";
+        } else if (!escaping && char === "$" && nextChar === "{") {
+          output += nextChar;
+          i += 2;
+          continue;
+        }
+        escaping = !escaping && char === "\\";
+        i++;
+        break;
+    }
+  }
+  return output;
+}
+
+// node_modules/.pnpm/@fangzhongya+utils@0.0.75/node_modules/@fangzhongya/utils/dist/chunk-4KYAGDPN.js
+var REGEX_PATTERNS = {
+  // export const/let/var variableName
+  VAR_EXPORT: /export\s+(?:const|let|var)\s+(\w+)/g,
+  // export function functionName
+  FUNCTION_EXPORT: /export\s+function\s+(\w+)/g,
+  // export class ClassName
+  CLASS_EXPORT: /export\s+class\s+(\w+)/g,
+  // export { a, b as c, d }
+  NAMED_EXPORTS: /export\s*\{([^}]+)\}/g,
+  // export default identifier
+  DEFAULT_EXPORT: /export\s+default\s+(\w+)/,
+  // 提取重命名后的名称
+  RENAME_SPLIT: /\s+as\s+/
+};
+function getExports(code) {
+  code = deComment(code);
+  const exports = {
+    named: [],
+    default: null
+  };
+  const namedExportsSet = /* @__PURE__ */ new Set();
+  const processMatches = (pattern, extractName) => {
+    const matches = code.matchAll(pattern);
+    for (const match of matches) {
+      const name = extractName(match);
+      if (name) {
+        namedExportsSet.add(name);
+      }
+    }
+  };
+  processMatches(REGEX_PATTERNS.VAR_EXPORT, (match) => match[1]);
+  processMatches(REGEX_PATTERNS.FUNCTION_EXPORT, (match) => match[1]);
+  processMatches(REGEX_PATTERNS.CLASS_EXPORT, (match) => match[1]);
+  const namedExportMatches = code.matchAll(REGEX_PATTERNS.NAMED_EXPORTS);
+  for (const match of namedExportMatches) {
+    const items = match[1];
+    if (!items) continue;
+    items.split(",").forEach((item) => {
+      const trimmed = item.trim();
+      if (!trimmed) return;
+      const parts = trimmed.split(REGEX_PATTERNS.RENAME_SPLIT);
+      const name = parts[parts.length - 1].trim();
+      if (name) {
+        namedExportsSet.add(name);
+      }
+    });
+  }
+  const defaultMatch = code.match(REGEX_PATTERNS.DEFAULT_EXPORT);
+  if (defaultMatch) {
+    exports.default = defaultMatch[1];
+  }
+  exports.named = Array.from(namedExportsSet).sort();
+  return exports;
+}
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.50/node_modules/@fangzhongya/create/dist/chunk-ER44O4IJ.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.50/node_modules/@fangzhongya/create/dist/chunk-A7RAGYE3.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.50/node_modules/@fangzhongya/create/dist/chunk-36XULS54.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, type2) {
+  if (!type2 || type2 === true) {
+    type2 = "utf-8";
+  }
+  return new Promise((resolve3, reject) => {
+    readFile(url, type2, (err, dataStr) => {
+      if (err) {
+        console.log("2", err);
+        reject("");
+      } else {
+        resolve3(dataStr);
+      }
+    });
+  });
+}
+function fsCreateReadStream(url, type2) {
+  if (!type2 || type2 === true) {
+    type2 = "utf-8";
+  }
+  return new Promise((resolve3) => {
+    const stream = createReadStream(url, {
+      start: 0,
+      end: 100,
+      encoding: type2
+    });
+    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, type2 = 0, cover, callback) {
+  open(path, "wx", async (err, fd) => {
+    if (err) {
+      if (err.code === "EEXIST") {
+        if (type2 == 1 || type2 == 0) {
+          const fwrite = () => {
+            writeFile(path, json, "utf-8", (err2) => {
+              if (err2) {
+                console.log("6", err2);
+                if (callback) {
+                  callback(path, cover ? 3 : 2, false, type2);
+                }
+              } else {
+                if (callback) {
+                  callback(path, cover ? 3 : 2, true, type2);
+                }
+              }
+            });
+          };
+          if (cover) {
+            const st = await fsCreateReadStream(path);
+            if (!st.includes("@config cover=true")) {
+              fwrite();
+            } else {
+              if (callback) callback(path, 3, false, type2);
+            }
+          } else {
+            fwrite();
+          }
+        } else if (type2 == 3) {
+          path = getNewFileName(path);
+          if (path) {
+            fsOpenStream(path, json, type2, cover, callback);
+          } else {
+            if (callback) {
+              callback(path, 3, false, type2);
+            }
+          }
+        } else {
+          if (callback) {
+            callback(path, 2, false, type2);
+          }
+        }
+      } else {
+        if (callback) {
+          callback(path, 0, false, type2);
+        }
+      }
+    } else {
+      if (type2 != 1) {
+        write(fd, json, (err2) => {
+          if (err2) {
+            console.log("8", err2);
+            if (callback) {
+              callback(path, 1, false, type2);
+            }
+          } else {
+            if (callback) {
+              callback(path, 1, true, type2);
+            }
+          }
+        });
+      } else {
+        if (callback) {
+          callback(path, 1, false, type2);
+        }
+      }
+    }
+  });
+}
+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.50/node_modules/@fangzhongya/create/dist/chunk-55GZI3ZZ.js
+import { resolve, join as join2 } from "path";
+function styleLog2(msg = "", obj) {
+  const arr = ["\x1B[0m"];
+  if (obj?.revert) {
+    arr.push("\x1B[4m");
+  }
+  if (obj?.lineThrough) {
+    arr.push("\x1B[9m");
+  }
+  if (obj?.italic) {
+    arr.push("\x1B[3m");
+  }
+  if (obj?.bold) {
+    arr.push("\x1B[1m");
+  }
+  if (obj?.bag) {
+    arr.push(`\x1B[4${obj?.bag}m`);
+  } else {
+    arr.push("\x1B[40m");
+  }
+  if (obj?.text) {
+    arr.push(`\x1B[3${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, type2) {
+    fsMkdir(getUrlCatalogue(url), (reaPath, is, ml) => {
+      const logs = this.getLogs();
+      logs.push(styleLog2("dir", {}));
+      if (is) {
+        if (ml) {
+          logs.push(
+            styleLog2("add", {
+              text: 2,
+              italic: true
+            })
+          );
+          logs.push(
+            styleLog2(reaPath, {
+              text: 2,
+              revert: true
+            })
+          );
+          console.log(logs.join(" "));
+        }
+      } else {
+        logs.push(
+          styleLog2(reaPath, {
+            text: 1,
+            revert: true
+          })
+        );
+        console.log(logs.join(" "));
+      }
+      this.setOpen(url, sts, type2, (kurl, _type, is2, _tn) => {
+        if (is2 && fileUrls) {
+          fileUrls.push(kurl);
+        }
+      });
+    });
+  }
+  /**
+   * 输出文件
+   * @param url
+   * @param str
+   * @param callback
+   */
+  setOpen(url, str, type2, 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 type2 != "undefined") {
+      tn = type2;
+    }
+    if (this.config.writeNotes && !/\.json$/.test(url)) {
+      str = this.getFileNotes(url).join("\n") + "\n" + str;
+    }
+    fsOpenStream(
+      url,
+      str,
+      tn,
+      this.config.coverConfig,
+      (kurl, type22, is) => {
+        if (!(tn == 2 && type22 == 2)) {
+          const logs = this.getLogs();
+          logs.push(styleLog2("file", {}));
+          if (type22 == 1) {
+            logs.push(
+              styleLog2("add", {
+                text: 2,
+                italic: true
+              })
+            );
+          } else if (type22 == 2) {
+            logs.push(
+              styleLog2("update", {
+                italic: true,
+                text: 4
+              })
+            );
+          }
+          if (is) {
+            logs.push(
+              styleLog2(kurl, {
+                text: 2,
+                revert: true
+              })
+            );
+          } else {
+            logs.push(
+              styleLog2(kurl, {
+                text: 1,
+                revert: true
+              })
+            );
+          }
+          console.log(logs.join(" "));
+        }
+        if (callback) {
+          callback(kurl, type22, is, tn);
+        }
+      }
+    );
+  }
+  /**
+   * 获取日志头
+   */
+  getLogs() {
+    const logs = [];
+    logs.push(
+      styleLog2("[@fangzhongya/create]", {
+        text: 3
+      })
+    );
+    logs.push(
+      styleLog2(this._defaultConfig.name, {
+        text: 4
+      })
+    );
+    return logs;
+  }
+};
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.50/node_modules/@fangzhongya/create/dist/chunk-VZKQWRZ3.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, type2) {
+    return new Promise((resolve22) => {
+      fsAccess(url).then(() => {
+        resolve22(fsReadFile(url, type2));
+      });
+    });
+  }
+  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;
+  }
+};
+async function runDev(config, configCallback, callback) {
+  const fang = new FangFile(config);
+  await fang.runDev(callback, configCallback);
+}
+
+// packages/imports.ts
+var type = "import";
+var FangImport = class {
+  config;
+  #comUrls;
+  #cacheObj;
+  #exports;
+  constructor(config) {
+    this.config = config || {};
+    this.#setConfigValue();
+  }
+  /**
+   * 初始化数据
+   */
+  #setConfigValue() {
+    this.#comUrls = [];
+    this.#cacheObj = {};
+    this.#exports = {};
+    this.#getUrls();
+  }
+  /**
+   * 读取url地址列表
+   */
+  #getUrls() {
+    runDev({
+      dir: this.config.dir,
+      extensions: this.config.extensions,
+      writeNotes: false,
+      coverConfig: false,
+      fileTongre: false,
+      fileCover: false,
+      issort: false,
+      issynch: false,
+      read: true,
+      matchs: this.config.matchs,
+      matchexts: this.config.matchexts,
+      nomatchs: this.config.nomatchs,
+      nomatchexts: this.config.nomatchexts,
+      fileSet: (name, url, text, wjm, _imp, surl) => {
+        const v = surl || join4(url, name);
+        const es = getExports(text);
+        const dm = wjm || name.replace(/\.([^.]+)$/, "");
+        if (es.default) {
+          es.default = dm;
+        }
+        this.#comUrls?.push(v);
+        this.#exports[v] = es;
+        return [];
+      }
+    });
+  }
+  /**
+   * 获取当前缓存数
+   * @param {String} name 名称
+   * @param {String} type 类型
+   * @returns { Object } 注册的对象
+   */
+  #getCache(name) {
+    if (this.#cacheObj) {
+      return this.#cacheObj[name];
+    }
+  }
+  /**
+   * 设置缓存数据
+   * @param {String} name 名称
+   * @param {String} type 类型
+   * @param { Object } 注册的对象
+   */
+  #setCache(name, obj) {
+    this.#cacheObj = this.#cacheObj || {};
+    this.#cacheObj[name] = obj;
+  }
+  /**
+   * 是否要替换
+   * @param { String } name 名称
+   * @returns { Boolean } 是否要替换
+   */
+  #namefilter(name) {
+    if (this.config.startss) {
+      for (let index = 0; index < this.config.startss.length; index++) {
+        const element = this.config.startss[index];
+        if (name.startsWith(element)) {
+          return false;
+        }
+      }
+    }
+    if (this.config.filtes) {
+      for (let index = 0; index < this.config.filtes.length; index++) {
+        const element = this.config.filtes[index];
+        if (name === element) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * 返回对应的值
+   * @param {String} from 文件地址
+   * @param {String} name 名称
+   * @returns  { Object } 注册的对象
+   */
+  #getNameFromUrl(name) {
+    const o = this.#exports || {};
+    const keys = Object.keys(o);
+    for (const key of keys) {
+      const es = o[key];
+      if (es.named.includes(name)) {
+        return {
+          name,
+          from: key
+        };
+      }
+      if (es.default === name) {
+        return {
+          name: "default",
+          from: key
+        };
+      }
+    }
+  }
+  /**
+   * 通过名称匹配对应路径
+   * @param {String} name 名称
+   * @param {String} type 类型
+   * @returns  { Object } 注册的对象
+   */
+  #setNameFrom(name) {
+    if (this.config.alias) {
+      name = name.replace(new RegExp("^" + this.config.alias), "");
+    }
+    return this.#getNameFromUrl(name);
+  }
+  /**
+   * 输出日志
+   * @param name
+   * @param type
+   * @param obj
+   * @param is
+   */
+  #setLog(name, obj, is) {
+    if (this.config.log) {
+      const texts = 1;
+      const arr = [];
+      arr.push(
+        styleLog("[@fangzhongya/vue-components]", {
+          text: 3
+        })
+      );
+      if (obj && obj.from) {
+        let sfrom = styleLog(obj?.from, {
+          text: 4,
+          revert: true
+        });
+        arr.push(
+          styleLog("import", {
+            text: texts
+          })
+        );
+        arr.push(
+          styleLog(name, {
+            bold: true
+          })
+        );
+        if (!is) {
+          sfrom = styleLog("+", {
+            text: 2
+          }) + sfrom;
+        }
+        arr.push(sfrom);
+      } else {
+        arr.push(
+          styleLog(type, {
+            text: texts
+          })
+        );
+        arr.push(
+          styleLog(name, {
+            bold: true,
+            text: 1
+          })
+        );
+      }
+      console.log(arr.join(" "));
+    }
+  }
+  /**
+   * 自动按需匹配注册
+   * @param {String} name 名称
+   * @param {String} type 类型
+   * @returns  { Object } 注册的对象
+   */
+  resolve(name) {
+    const cache = this.#getCache(name);
+    if (this.config.isCache && cache) {
+      this.#setLog(name, cache, true);
+      return cache;
+    } else if (this.#namefilter(name)) {
+      let obj = this.#setNameFrom(name);
+      this.#setLog(name, obj);
+      if (obj) {
+        this.#setCache(name, obj);
+        return obj;
+      }
+    }
+  }
+};
+var imports_default = FangImport;
+
+export {
+  imports_default
+};