@vtj/local 0.9.30 → 0.10.1-alpha.0

package/dist/index.cjs

@@ -0,0 +1,1259 @@
+'use strict';
+
+const cli = require('@vtj/cli');
+const node = require('@vtj/node');
+const path = require('path');
+const bodyParser = require('body-parser');
+const formidable = require('formidable');
+const core = require('@vtj/core');
+const coder = require('@vtj/coder');
+const parser = require('@vtj/parser');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const bodyParser__default = /*#__PURE__*/_interopDefaultCompat(bodyParser);
+const formidable__default = /*#__PURE__*/_interopDefaultCompat(formidable);
+
+const success = (data) => {
+  return {
+    code: 0 /* Success */,
+    msg: "success",
+    data,
+    success: true
+  };
+};
+const fail = (msg, data = null, stack = null) => {
+  return {
+    code: 1 /* Fail */,
+    msg,
+    data,
+    stack,
+    success: false
+  };
+};
+const CLIENT_DIR = "__vtj__";
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class JsonRepository {
+  constructor(path$1, platform = "web") {
+    __publicField$3(this, "path");
+    const dir = platform === "uniapp" ? "src/vtj" : ".vtj";
+    this.path = path.resolve(dir, path$1);
+  }
+  exist(name) {
+    const filePath = path.join(this.path, `${name}.json`);
+    return node.pathExistsSync(filePath);
+  }
+  save(name, json) {
+    const filePath = path.join(this.path, `${name}.json`);
+    if (!this.exist(name)) {
+      node.ensureFileSync(filePath);
+    }
+    node.writeJsonSync(filePath, json, {
+      spaces: 2,
+      EOL: "\n"
+    });
+    return true;
+  }
+  get(name) {
+    const filePath = path.join(this.path, `${name}.json`);
+    if (node.pathExistsSync(filePath)) {
+      return node.readJsonSync(filePath);
+    } else {
+      return void 0;
+    }
+  }
+  remove(name) {
+    const filePath = path.join(this.path, `${name}.json`);
+    if (node.pathExistsSync(filePath)) {
+      node.removeSync(filePath);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    if (node.pathExistsSync(this.path)) {
+      node.removeSync(this.path);
+      return true;
+    }
+    return false;
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class VueRepository {
+  constructor(platform = "web") {
+    __publicField$2(this, "path");
+    const dir = platform === "uniapp" ? "src/pages" : ".vtj/vue";
+    this.path = path.resolve(dir);
+  }
+  exist(name) {
+    const filePath = path.join(this.path, `${name}.vue`);
+    return node.pathExistsSync(filePath);
+  }
+  save(name, content) {
+    const filePath = path.join(this.path, `${name}.vue`);
+    if (!this.exist(name)) {
+      node.ensureFileSync(filePath);
+    }
+    node.outputFileSync(filePath, content, "utf-8");
+    return true;
+  }
+  remove(name) {
+    const filePath = path.join(this.path, `${name}.vue`);
+    if (node.pathExistsSync(filePath)) {
+      node.removeSync(filePath);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    if (node.pathExistsSync(this.path)) {
+      node.removeSync(this.path);
+      return true;
+    }
+    return false;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class StaticRepository {
+  constructor(options) {
+    this.options = options;
+    __publicField$1(this, "path");
+    this.path = path.resolve(this.options.staticDir, this.options.vtjDir);
+  }
+  exist(name) {
+    const filePath = path.join(this.path, name);
+    return node.pathExistsSync(filePath);
+  }
+  remove(name) {
+    const filePath = path.join(this.path, name);
+    if (node.pathExistsSync(filePath)) {
+      node.removeSync(filePath);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    if (node.pathExistsSync(this.path)) {
+      node.removeSync(this.path);
+      return true;
+    }
+    return false;
+  }
+  getAllFiles() {
+    if (node.pathExistsSync(this.path)) {
+      const files = node.readdirSync(this.path) || [];
+      return files.map((name) => {
+        return {
+          filename: name,
+          filepath: path.join(
+            this.options.staticBase,
+            this.options.vtjDir,
+            name
+          ).replace(/\\/g, "/")
+        };
+      });
+    }
+    return [];
+  }
+  validate(files) {
+    let isExists = false;
+    const result = [];
+    for (let file of files) {
+      if (file.originalFilename) {
+        const filePath = path.join(this.path, file.originalFilename);
+        if (node.pathExistsSync(filePath)) {
+          isExists = true;
+          result.push({
+            filename: file.originalFilename,
+            filepath: path.join(
+              this.options.staticBase,
+              this.options.vtjDir,
+              file.originalFilename
+            ).replace(/\\/g, "/")
+          });
+          break;
+        }
+      }
+    }
+    if (isExists) {
+      for (let file of files) {
+        if (file.filepath) {
+          if (node.pathExistsSync(file.filepath)) {
+            node.removeSync(file.filepath);
+          }
+        }
+      }
+    }
+    return isExists ? result : false;
+  }
+  save(files) {
+    const result = [];
+    for (let file of files) {
+      if (file.filepath && file.originalFilename) {
+        const filePath = path.join(this.path, file.originalFilename);
+        node.moveSync(file.filepath, filePath, { overwrite: true });
+        result.push({
+          filename: file.originalFilename,
+          filepath: path.join(
+            this.options.staticBase,
+            this.options.vtjDir,
+            file.originalFilename
+          ).replace(/\\/g, "/")
+        });
+      }
+    }
+    return result;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class PluginRepository {
+  constructor(pkg, opts) {
+    this.pkg = pkg;
+    this.opts = opts;
+    __publicField(this, "deps", []);
+    const { devDependencies, dependencies } = pkg || {};
+    const { presetPlugins } = opts;
+    this.deps = Object.keys({ ...devDependencies, ...dependencies }).filter(
+      (name) => presetPlugins.some((regex) => name.startsWith(regex))
+    );
+  }
+  getName(dep) {
+    const { presetPlugins } = this.opts;
+    let name = dep;
+    for (const regex of presetPlugins) {
+      name = name.replace(regex, "x-");
+    }
+    return node.upperFirstCamelCase(name);
+  }
+  getPlugins() {
+    const { vtj = {} } = this.pkg;
+    const { pluginNodeModulesDir = "node_modules", staticBase = "/" } = this.opts;
+    const plugins = (vtj.plugins || []).map((n) => {
+      n.type = "block";
+      n.fromType = "Plugin";
+      n.preset = true;
+      n.category = "\u63D2\u4EF6\u533A\u5757";
+      return n;
+    });
+    const ext = [".css", ".js", ".json"];
+    for (const dep of this.deps) {
+      const dist = path.join(pluginNodeModulesDir, dep, "dist");
+      if (node.pathExistsSync(dist)) {
+        const pkg = node.readJsonSync(
+          path.join(pluginNodeModulesDir, dep, "package.json")
+        );
+        const files = node.readdirSync(dist, { recursive: true, encoding: "utf-8" });
+        const urls = files.filter((url) => ext.some((n) => url.endsWith(n))).map(
+          (url) => `${staticBase}@vtj/plugins/${url.replace(/\\/gi, "/")}`
+        );
+        const { description } = pkg || "";
+        const name = node.upperFirstCamelCase(dep);
+        if (files.length) {
+          plugins.push({
+            type: "block",
+            fromType: "Plugin",
+            preset: true,
+            id: dep,
+            name: this.getName(dep),
+            title: description || name,
+            library: name,
+            urls: urls.join(","),
+            category: "\u63D2\u4EF6\u533A\u5757"
+          });
+        }
+      }
+    }
+    return plugins;
+  }
+}
+
+const APP_LIFE_CYCLE = [
+  "onLaunch",
+  "onShow",
+  "onHide",
+  "onError",
+  "onPageNotFound",
+  "onUnhandledRejection",
+  "onThemeChange",
+  "onPageNotFound",
+  "onUniNViewMessage",
+  "onExit"
+];
+const vueAppTempalte = `
+<script setup lang="ts">
+{{ts}}
+<\/script>
+<style>
+{{css}}
+</style>
+`;
+class UniRepository {
+  constructor() {
+  }
+  createProjectPages(project) {
+    const oPages = (project.uniConfig?.pagesJson?.pages || []).filter(
+      (n) => !n.vtj
+    );
+    const pages = project.pages || [];
+    const json = [];
+    for (const page of pages) {
+      if (page.id === project.homepage) {
+        json.unshift({
+          path: `pages/${page.id}`,
+          style: page.style || {},
+          needLogin: page.needLogin,
+          vtj: true
+        });
+      } else {
+        json.push({
+          path: `pages/${page.id}`,
+          style: page.style || {},
+          needLogin: page.needLogin,
+          vtj: true
+        });
+      }
+    }
+    for (const item of oPages) {
+      const exist = json.find((n) => n.path === item.path);
+      if (!exist) {
+        json.push(item);
+      }
+    }
+    return json;
+  }
+  savePagesJson(project) {
+    const pages = this.createProjectPages(project);
+    const { pagesJson = {} } = project.uniConfig || {};
+    const filePath = path.resolve("src/pages.json");
+    pagesJson.pages = pages;
+    node.writeJsonSync(filePath, pagesJson, {
+      spaces: 2,
+      EOL: "\n"
+    });
+    return true;
+  }
+  saveManifestJson(project) {
+    const { manifestJson } = project.uniConfig || {};
+    const filePath = path.resolve("src/manifest.json");
+    node.writeJsonSync(filePath, manifestJson, {
+      spaces: 2,
+      EOL: "\n"
+    });
+    return true;
+  }
+  async saveApp(project) {
+    const filePath = path.resolve("src/App.vue");
+    const uniConfig = project.uniConfig || {};
+    const names = [];
+    const content = [];
+    for (const [name, value] of Object.entries(uniConfig)) {
+      if (APP_LIFE_CYCLE.includes(name) && value.value) {
+        names.push(name);
+        const code = value.value.replace(/;\n/g, "\n");
+        content.push(`${name}(${code})`);
+      }
+    }
+    const tsCode = names.length ? `import {${names.join(",")}} from '@dcloudio/uni-app';${content.join(";\n")}` : "";
+    const css = uniConfig.css || "";
+    let result = vueAppTempalte.replace("{{ts}}", await coder.tsFormatter(tsCode));
+    result = result.replace("{{css}}", await coder.cssFormatter(css));
+    node.outputFileSync(filePath, await coder.vueFormatter(result), "utf-8");
+  }
+}
+
+const manifestJson = {
+  name: "VTJ",
+  appid: "__UNI__1FC118B",
+  description: "VTJ\u79FB\u52A8\u8DE8\u7AEF\u9879\u76EE\u6A21\u677F",
+  versionName: "1.0.0",
+  versionCode: "100",
+  transformPx: false,
+  "app-plus": {
+    usingComponents: true,
+    nvueStyleCompiler: "uni-app",
+    compilerVersion: 3,
+    splashscreen: {
+      alwaysShowBeforeRender: true,
+      waiting: true,
+      autoclose: true,
+      delay: 0
+    },
+    modules: {},
+    distribute: {
+      android: {
+        permissions: [
+          '<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>',
+          '<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>',
+          '<uses-permission android:name="android.permission.VIBRATE"/>',
+          '<uses-permission android:name="android.permission.READ_LOGS"/>',
+          '<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>',
+          '<uses-feature android:name="android.hardware.camera.autofocus"/>',
+          '<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>',
+          '<uses-permission android:name="android.permission.CAMERA"/>',
+          '<uses-permission android:name="android.permission.GET_ACCOUNTS"/>',
+          '<uses-permission android:name="android.permission.READ_PHONE_STATE"/>',
+          '<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>',
+          '<uses-permission android:name="android.permission.WAKE_LOCK"/>',
+          '<uses-permission android:name="android.permission.FLASHLIGHT"/>',
+          '<uses-feature android:name="android.hardware.camera"/>',
+          '<uses-permission android:name="android.permission.WRITE_SETTINGS"/>'
+        ]
+      },
+      ios: {},
+      sdkConfigs: {},
+      icons: {
+        android: {
+          hdpi: "src/static/logo.png",
+          xhdpi: "src/static/logo.png",
+          xxhdpi: "src/static/logo.png",
+          xxxhdpi: "src/static/logo.png"
+        }
+      }
+    }
+  },
+  quickapp: {},
+  "mp-weixin": {
+    appid: "",
+    setting: {
+      urlCheck: false
+    },
+    usingComponents: true
+  },
+  "mp-alipay": {
+    usingComponents: true
+  },
+  "mp-baidu": {
+    usingComponents: true
+  },
+  "mp-toutiao": {
+    usingComponents: true
+  },
+  uniStatistics: {
+    enable: false
+  },
+  vueVersion: "3"
+};
+
+const pagesJson = {
+  pages: [],
+  globalStyle: {
+    navigationBarTextStyle: "black",
+    navigationBarTitleText: "uni-app",
+    navigationBarBackgroundColor: "#F8F8F8",
+    backgroundColor: "#F8F8F8"
+  }
+};
+
+function isJSFunction(x) {
+  return typeof x === "object" && x && x.type === "JSFunction";
+}
+function getJson(name, dsl) {
+  const map = {
+    manifestJson: "manifest.json",
+    pagesJson: "pages.json"
+  };
+  const defaults = {
+    manifestJson: manifestJson,
+    pagesJson: pagesJson
+  };
+  const file = map[name];
+  const filePath = path.resolve("./src", file);
+  if (node.pathExistsSync(filePath)) {
+    return node.readJsonSync(filePath);
+  }
+  const uniConfig = dsl.uniConfig || {};
+  return uniConfig[name] || defaults[name];
+}
+function getApp(dsl) {
+  const filePath = path.resolve("./src/App.vue");
+  if (node.pathExistsSync(filePath)) {
+    const source = node.fs.readFileSync(filePath, "utf-8");
+    return parser.parseUniApp(source);
+  }
+  return dsl.uniConfig || {};
+}
+async function formatUniConfigCode(uniConfig) {
+  for (const [name, value] of Object.entries(uniConfig)) {
+    if (isJSFunction(value)) {
+      const code = uniConfig[name].value;
+      uniConfig[name].value = await coder.tsFormatter(code);
+    }
+  }
+  return uniConfig;
+}
+async function getUniConfig(dsl) {
+  const manifestJson = getJson("manifestJson", dsl);
+  const pagesJson = getJson("pagesJson", dsl);
+  const lifeCycle = getApp(dsl);
+  const { name, id, description } = dsl;
+  const appId = node.camelCase(id?.replace(/\//, "__")).toUpperCase();
+  Object.assign(manifestJson, {
+    name,
+    appid: appId.startsWith("__UNI__") ? appId : `__UNI__${appId}`,
+    description
+  });
+  return {
+    ...dsl.uniConfig,
+    ...await formatUniConfigCode(lifeCycle),
+    manifestJson,
+    pagesJson
+  };
+}
+
+let isInit = false;
+let _platform = "web";
+async function saveLogs(e) {
+  const name = `error-${node.timestamp()}`;
+  const logs = new JsonRepository("logs", _platform);
+  const json = JSON.parse(JSON.stringify(e));
+  return logs.save(name, json);
+}
+async function getExtension(_body, opts) {
+  const root = path.resolve("./");
+  const pkg = node.readJsonSync(path.resolve(root, "package.json"));
+  const { vtj = {} } = pkg || {};
+  const adapters = {
+    remote: "https://lcdp.vtj.pro",
+    access: {
+      auth: "/auth.html",
+      privateKey: "MIIBOgIBAAJBAKoIzmn1FYQ1YOhOBw9EhABxZ+PySAIaydI+zdhoKflrdgJ4A5E4/5gbQmRpk09hPWG8nvX7h+l/QLU8kXxAIBECAwEAAQJAAlgpxQY6sByLsXqzJcthC8LSGsLf2JEJkHwlnpwFqlEV8UCkoINpuZ2Wzl+aftURu5rIfAzRCQBvHmeOTW9/zQIhAO5ufWDmnSLyfAAsNo5JRNpVuLFCFodR8Xm+ulDlosR/AiEAtpAltyP9wmCABKG/v/hrtTr3mcvFNGCjoGa9bUAok28CIHbrVs9w1ijrBlvTsXYwJw46uP539uKRRT4ymZzlm9QjAiB+1KH/G9f9pEEL9rtaSOG7JF5D0JcOjlze4MGVFs+ZrQIhALKOUFBNr2zEsyJIjw2PlvEucdlG77UniszjXTROHSPd"
+    }
+  };
+  const extension = {
+    ...vtj.extension || {},
+    history: vtj.history || "hash",
+    base: vtj.base || "/",
+    pageRouteName: vtj.pageRouteName || (vtj.platform === "uniapp" ? "pages" : "page"),
+    __BASE_PATH__: opts.staticBase,
+    __adapters__: node.merge({}, adapters, vtj.adapters || {})
+  };
+  return success(extension);
+}
+async function init(_body, opts) {
+  const root = path.resolve("./");
+  const pkg = node.readJsonSync(path.resolve(root, "package.json"));
+  const pluginPepository = new PluginRepository(pkg, opts);
+  const { vtj = {} } = pkg || {};
+  const id = vtj.id || pkg.name;
+  const name = vtj.name || pkg.description || node.upperFirstCamelCase(id);
+  const description = vtj.description || pkg.description || "";
+  const platform = vtj.platform || "web";
+  _platform = platform;
+  const repository = new JsonRepository("projects", _platform);
+  let dsl = repository.get(id);
+  const plugins = pluginPepository.getPlugins();
+  if (dsl) {
+    const blocks = (dsl.blocks || []).filter((n) => !n.preset);
+    dsl.blocks = plugins.concat(blocks);
+    Object.assign(dsl, { id, name, description, platform });
+    if (platform === "uniapp") {
+      dsl.uniConfig = await getUniConfig(dsl);
+    }
+    if (!isInit) {
+      isInit = true;
+      repository.save(id, dsl);
+    }
+    dsl.__BASE_PATH__ = opts.staticBase;
+    return success(dsl);
+  } else {
+    const model = new core.ProjectModel({
+      id,
+      name,
+      description,
+      platform,
+      blocks: plugins
+    });
+    dsl = model.toDsl();
+    if (platform === "uniapp") {
+      dsl.uniConfig = await getUniConfig(dsl);
+    }
+    repository.save(id, dsl);
+    dsl.__BASE_PATH__ = opts.staticBase;
+    return success(dsl);
+  }
+}
+async function saveProject(dsl, type) {
+  const repository = new JsonRepository("projects", dsl.platform);
+  if (repository.exist(dsl.id)) {
+    const ret = repository.save(dsl.id, dsl);
+    if (dsl.platform === "uniapp") {
+      await genUniConfig(dsl, type === "delete");
+    }
+    return success(ret);
+  } else {
+    return fail("\u9879\u76EE\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+async function saveFile(dsl) {
+  const repository = new JsonRepository("files", _platform);
+  const ret = repository.save(dsl.id, dsl);
+  return success(ret);
+}
+async function getFile(id) {
+  const repository = new JsonRepository("files", _platform);
+  const json = repository.get(id);
+  if (json) {
+    return success(json);
+  } else {
+    return fail("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+async function removeFile(id) {
+  const repository = new JsonRepository("files", _platform);
+  const ret = repository.remove(id);
+  return success(ret);
+}
+async function getHistory(id) {
+  const repository = new JsonRepository("histories", _platform);
+  const json = repository.get(id);
+  if (json) {
+    return success(json);
+  } else {
+    return success({});
+  }
+}
+async function saveHistory(file) {
+  const repository = new JsonRepository("histories", _platform);
+  const ret = repository.save(file.id, file);
+  return success(ret);
+}
+async function removeHistory(id) {
+  const repository = new JsonRepository("histories", _platform);
+  const items = new JsonRepository(`histories/${id}`, _platform);
+  items.clear();
+  repository.remove(id);
+  return success(true);
+}
+async function getHistoryItem(fId, id) {
+  const repository = new JsonRepository(`histories/${fId}`, _platform);
+  const json = repository.get(id);
+  if (json) {
+    return success(json);
+  } else {
+    return fail("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+async function saveHistoryItem(fId, item) {
+  const repository = new JsonRepository(`histories/${fId}`, _platform);
+  repository.save(item.id, item);
+  return success(true);
+}
+async function removeHistoryItem(fId, ids) {
+  const repository = new JsonRepository(`histories/${fId}`, _platform);
+  ids.forEach((id) => {
+    repository.remove(id);
+  });
+  return success(true);
+}
+async function saveMaterials(project, materials) {
+  const repository = new JsonRepository("materials", _platform);
+  repository.save(project.id, materials);
+  return success(true);
+}
+async function publishFile(project, file, componentMap) {
+  const materialsRepository = new JsonRepository("materials", project.platform);
+  const materials = materialsRepository.get(project.id);
+  componentMap = componentMap || new Map(Object.entries(materials || {}));
+  const fileRepository = new JsonRepository("files", project.platform);
+  const dsl = fileRepository.get(file.id);
+  if (dsl) {
+    const content = await coder.generator(
+      dsl,
+      componentMap,
+      project.dependencies,
+      project.platform
+    ).catch((e) => {
+      try {
+        saveLogs({
+          dsl,
+          componentMap,
+          dependencies: project.dependencies,
+          message: e.message,
+          stack: e.stack
+        });
+      } catch (e2) {
+      }
+      throw e;
+    });
+    const vueRepository = new VueRepository(_platform);
+    vueRepository.save(file.id, content);
+    return success(true);
+  } else {
+    return fail("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+async function publish(project) {
+  const { pages = [], blocks = [] } = project;
+  const materialsRepository = new JsonRepository("materials", project.platform);
+  const materials = materialsRepository.get(project.id);
+  const componentMap = new Map(
+    Object.entries(materials)
+  );
+  for (const block of blocks) {
+    if (!block.fromType || block.fromType === "Schema") {
+      await publishFile(project, block, componentMap);
+    }
+  }
+  for (const page of pages) {
+    if (!page.raw) {
+      await publishFile(project, page, componentMap);
+    }
+  }
+  if (project.platform === "uniapp") {
+    await genUniConfig(project, true);
+  }
+  return success(true);
+}
+async function genUniConfig(project, injectPages = false) {
+  const uniRepository = new UniRepository();
+  uniRepository.saveManifestJson(project);
+  if (injectPages) {
+    uniRepository.savePagesJson(project);
+  }
+  await uniRepository.saveApp(project);
+  return success(true);
+}
+async function genVueContent(project, dsl) {
+  const materialsRepository = new JsonRepository("materials", project.platform);
+  const materials = materialsRepository.get(project.id);
+  const componentMap = new Map(
+    Object.entries(materials)
+  );
+  const content = await coder.generator(
+    dsl,
+    componentMap,
+    project.dependencies,
+    project.platform
+  ).catch((e) => {
+    throw e;
+  });
+  return success(content);
+}
+async function createRawPage(file) {
+  const repository = new VueRepository(_platform);
+  const page = await coder.createEmptyPage(file);
+  repository.save(file.id, page);
+  return success(true);
+}
+async function removeRawPage(id) {
+  const repository = new VueRepository(_platform);
+  repository.remove(id);
+  return success(true);
+}
+async function uploadStaticFiles(files, options) {
+  const repository = new StaticRepository(options);
+  const error = repository.validate(files);
+  if (error) {
+    return fail("\u6587\u4EF6\u540D\u79F0\u5DF2\u5B58\u5728", error);
+  }
+  const res = repository.save(files);
+  return success(res);
+}
+async function removeStaticFile(filename, options) {
+  const repository = new StaticRepository(options);
+  const ret = repository.remove(filename);
+  return ret ? success(true) : fail("\u5220\u9664\u5931\u8D25");
+}
+async function getStaticFiles(options) {
+  const repository = new StaticRepository(options);
+  return success(repository.getAllFiles());
+}
+async function clearStaticFiles(options) {
+  const repository = new StaticRepository(options);
+  return success(repository.clear());
+}
+
+const controller = {
+  notMatch: async (_req) => {
+    return fail("\u627E\u4E0D\u5230\u5904\u7406\u7A0B\u5E8F");
+  },
+  getExtension: getExtension,
+  init: init,
+  saveProject: async (req) => {
+    const project = req.data;
+    return saveProject(project, req.query?.type);
+  },
+  saveFile: async (req) => {
+    const file = req.data;
+    return saveFile(file);
+  },
+  getFile: async (req) => {
+    const id = req.data;
+    return getFile(id);
+  },
+  removeFile: async (req) => {
+    const id = req.data;
+    return removeFile(id);
+  },
+  getHistory: async (req) => {
+    const id = req.data;
+    return getHistory(id);
+  },
+  saveHistory: async (req) => {
+    const file = req.data;
+    return saveHistory(file);
+  },
+  removeHistory: async (req) => {
+    const id = req.data;
+    return removeHistory(id);
+  },
+  getHistoryItem: async (req) => {
+    const { fId, id } = req.data || {};
+    return getHistoryItem(fId, id);
+  },
+  saveHistoryItem: async (req) => {
+    const { fId, item } = req.data || {};
+    return saveHistoryItem(fId, item);
+  },
+  removeHistoryItem: async (req) => {
+    const { fId, ids = [] } = req.data || {};
+    return removeHistoryItem(fId, ids);
+  },
+  saveMaterials: async (req) => {
+    const { project, materials } = req.data || {};
+    return saveMaterials(project, materials);
+  },
+  publishFile: async (req) => {
+    const { project, file } = req.data || {};
+    const result = await publishFile(project, file);
+    if (project.platform === "uniapp") {
+      await genUniConfig(project, true);
+    }
+    return result;
+  },
+  publish: async (req) => {
+    const project = req.data || {};
+    return publish(project);
+  },
+  genVueContent: async (req) => {
+    const { project, dsl } = req.data || {};
+    return genVueContent(project, dsl);
+  },
+  createRawPage: async (req) => {
+    const file = req.data;
+    return createRawPage(file);
+  },
+  removeRawPage: async (req) => {
+    const id = req.data;
+    return removeRawPage(id);
+  },
+  getStaticFiles: async (_req, opts) => {
+    return getStaticFiles(opts);
+  },
+  removeStaticFile: async (req, opts) => {
+    const name = req.data?.name;
+    return removeStaticFile(name, opts);
+  },
+  clearStaticFiles: async (_req, opts) => {
+    return clearStaticFiles(opts);
+  },
+  uploader: async (req, opts) => {
+    if (!opts)
+      return fail("\u5F02\u5E38\u9519\u8BEF");
+    const uploadDir = path.resolve(opts.staticDir, opts.vtjDir);
+    const form = formidable__default({
+      keepExtensions: true,
+      multiples: true,
+      createDirsFromUploads: true,
+      uploadDir
+    });
+    return await new Promise((reslove) => {
+      form.parse(req, (err, _fields, files) => {
+        if (err) {
+          reslove(fail("\u5F02\u5E38\u9519\u8BEF", err));
+          return;
+        }
+        const tempFiles = files.files || [];
+        const result = uploadStaticFiles(tempFiles, opts);
+        reslove(result);
+      });
+    });
+  }
+};
+function parse(str, sep, eq) {
+  const obj = {};
+  str = str.replace(/^[^]*\?/, "");
+  sep = sep || "&";
+  eq = eq || "=";
+  let arr;
+  const reg = new RegExp(
+    "(?:^|\\" + sep + ")([^\\" + eq + "\\" + sep + "]+)(?:\\" + eq + "([^\\" + sep + "]*))?",
+    "g"
+  );
+  while ((arr = reg.exec(str)) !== null) {
+    if (arr[1] !== str) {
+      obj[decodeURIComponent(arr[1])] = decodeURIComponent(arr[2] || "");
+    }
+  }
+  return obj;
+}
+const router = async (req, opts) => {
+  const body = req.body || {};
+  body.query = parse(req.url);
+  const reqUrl = req.url || "";
+  const uploaderPath = `${opts.baseURL}${opts.uploader}`;
+  const isUploader = reqUrl.startsWith(uploaderPath);
+  if (isUploader) {
+    return await controller.uploader(req, opts);
+  } else {
+    const handler = controller[body.type] || controller.notMatch;
+    try {
+      return await handler(body, opts);
+    } catch (e) {
+      const info = {
+        input: body,
+        error: {
+          message: e?.message,
+          stack: e?.stack
+        }
+      };
+      await saveLogs(info);
+      return fail("\u5F02\u5E38\u9519\u8BEF", e?.message, e?.stack);
+    }
+  }
+};
+
+const setApis = (server, options) => {
+  server.middlewares.use((req, res, next) => {
+    const reqUrl = req.url || "";
+    if (reqUrl.startsWith(options.baseURL)) {
+      bodyParser__default.json({ type: "application/json", limit: "50000kb" })(
+        req,
+        res,
+        next
+      );
+    } else {
+      next();
+    }
+  });
+  server.middlewares.use(async (req, res, next) => {
+    const reqUrl = req.url || "";
+    if (reqUrl.startsWith(options.baseURL)) {
+      const data = await router(req, options);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(data));
+    } else {
+      next();
+    }
+  });
+};
+const apiServerPlugin = function(options) {
+  return {
+    name: "vtj-api-plugin",
+    apply: "serve",
+    configureServer(server) {
+      setApis(server, options);
+    },
+    configurePreviewServer(server) {
+      return () => {
+        setApis(server, options);
+      };
+    }
+  };
+};
+const linkPlugin = function(options) {
+  const {
+    entry = "/index.html",
+    href = "",
+    serveOnly = true
+  } = options.linkOptions || {};
+  let config;
+  return {
+    name: "vtj-link-plugin",
+    apply: serveOnly ? "serve" : void 0,
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    transformIndexHtml(html, ctx) {
+      if (html.includes("__VTJ_LINK__")) {
+        return html;
+      }
+      if (options.link) {
+        if (ctx.path !== entry) {
+          return html;
+        }
+        const link = typeof options.link === "string" ? options.link : `${CLIENT_DIR}/entry/index.js`;
+        const url = `${config.base}${link}`;
+        return html.replace(
+          /<\/body>/,
+          `
+          <script>window.__VTJ_LINK__ = { href: '${href}' }<\/script>
+          <script src="${url}"><\/script></body>
+          `
+        );
+      }
+      return html;
+    }
+  };
+};
+const hmPlugin = function(options) {
+  const { hm } = options;
+  return {
+    name: "vtj-hm-plugin",
+    transformIndexHtml(html) {
+      return html.replace(
+        /<\/body>/,
+        `
+        <script>
+        (function () {
+          window._hmt = window._hmt || [];
+          const hm = document.createElement('script');
+          hm.src = 'https://hm.baidu.com/hm.js?${hm}';
+          var s = document.getElementsByTagName('script')[0];
+          s.parentNode.insertBefore(hm, s);
+        })();       
+        <\/script>
+        `
+      );
+    }
+  };
+};
+const aliasPlugin = function(options) {
+  return {
+    name: "vtj-alias-plugin",
+    config(config) {
+      const { root = process.cwd() } = config || {};
+      const vtjDir = path.join(root, options.vtjDir);
+      const packagesDir = path.join(root, options.packagesDir);
+      const devAlias = options.devMode && process.env.NODE_ENV === "development" ? {
+        "@vtj/ui/dist/style.css": path.join(
+          packagesDir,
+          "ui/src/style/index.scss"
+        ),
+        "@vtj/icons/dist/style.css": path.join(
+          packagesDir,
+          "icons/src/style.scss"
+        ),
+        "@vtj/designer/dist/style.css": path.join(
+          packagesDir,
+          "designer/src/style/index.scss"
+        ),
+        "@vtj/uni/dist/style.css": path.join(
+          packagesDir,
+          "uni/src/index.scss"
+        ),
+        "@vtj/base": path.join(packagesDir, "base/src"),
+        "@vtj/utils": path.join(packagesDir, "utils/src/index.ts"),
+        "@vtj/icons/svg": path.join(packagesDir, "icons/dist/svg.ts"),
+        "@vtj/icons": path.join(packagesDir, "icons/src"),
+        "@vtj/ui": path.join(packagesDir, "ui/src"),
+        "@vtj/charts": path.join(packagesDir, "charts/src"),
+        "@vtj/core": path.join(packagesDir, "core/src"),
+        "@vtj/designer": path.join(packagesDir, "designer/src"),
+        "@vtj/renderer": path.join(packagesDir, "renderer/src"),
+        "@vtj/coder": path.join(packagesDir, "coder/src"),
+        "@vtj/uni": path.join(packagesDir, "uni/src")
+      } : {};
+      if (config.resolve) {
+        let alias = config.resolve.alias || {};
+        if (Array.isArray(alias)) {
+          alias.push({
+            find: "$vtj",
+            replacement: vtjDir
+          });
+          alias.push(
+            ...Object.entries(devAlias).map(([find, replacement]) => ({
+              find,
+              replacement
+            }))
+          );
+        } else {
+          Object.assign(alias, {
+            $vtj: vtjDir,
+            ...devAlias
+          });
+        }
+        config.resolve.alias = alias;
+      } else {
+        config.resolve = {
+          alias: {
+            $vtj: vtjDir,
+            ...devAlias
+          }
+        };
+      }
+    }
+  };
+};
+function parsePresetPlugins(options) {
+  const {
+    presetPlugins = [],
+    pluginNodeModulesDir = "node_modules",
+    staticBase
+  } = options;
+  const pkg = node.readJsonSync(path.resolve("./package.json"));
+  const { devDependencies, dependencies } = pkg || {};
+  const deps = Object.keys({ ...devDependencies, ...dependencies }).filter(
+    (name) => presetPlugins.some((regex) => name.startsWith(regex))
+  );
+  const copies = [];
+  const staticDirs = [];
+  for (const dep of deps) {
+    const dist = path.join(pluginNodeModulesDir, dep, "dist");
+    if (node.pathExistsSync(dist)) {
+      copies.push({
+        from: dist,
+        to: "@vtj/plugins",
+        emptyDir: false
+      });
+      staticDirs.push({
+        path: `${staticBase}@vtj/plugins`,
+        dir: dist
+      });
+    }
+  }
+  return {
+    copies,
+    staticDirs
+  };
+}
+function createDevTools(options = {}) {
+  const opts = {
+    baseURL: `/${CLIENT_DIR}/api`,
+    copy: true,
+    server: true,
+    staticBase: "/",
+    staticDir: "public",
+    link: true,
+    linkOptions: null,
+    vtjDir: ".vtj",
+    packagesDir: "../../packages",
+    devMode: false,
+    uploader: "/uploader.json",
+    packageName: "@vtj/pro",
+    nodeModulesDir: "node_modules",
+    presetPlugins: ["@newpearl/plugin-", "@vtj/plugin-"],
+    pluginNodeModulesDir: "node_modules",
+    extensionDir: "",
+    materialDirs: [],
+    hm: "42f2469b4aa27c3f8978f634c0c19d24",
+    ...options
+  };
+  const plugins = [aliasPlugin(opts)];
+  const proPath = `${opts.nodeModulesDir}/${opts.packageName}/dist`;
+  const materialsPath1 = `${opts.nodeModulesDir}/@vtj/materials/dist`;
+  const materialsPath2 = `${opts.nodeModulesDir}/${opts.packageName}/${materialsPath1}`;
+  const materialDirs = opts.materialDirs.map((n) => {
+    return `${opts.pluginNodeModulesDir}/${n}/dist`;
+  });
+  if (opts.copy) {
+    const copyOptions = [];
+    if (node.pathExistsSync(materialsPath1)) {
+      copyOptions.push({
+        from: materialsPath1,
+        to: "@vtj/materials",
+        emptyDir: true
+      });
+    } else if (node.pathExistsSync(materialsPath2)) {
+      copyOptions.push({
+        from: materialsPath2,
+        to: "@vtj/materials",
+        emptyDir: true
+      });
+    } else {
+      console.warn(
+        "\n @vtj/materials is not installed, please install it first.\n"
+      );
+    }
+    materialDirs.forEach((form) => {
+      copyOptions.push({
+        from: form,
+        to: "@vtj/materials",
+        emptyDir: false
+      });
+    });
+    if (opts.extensionDir && node.pathExistsSync(opts.extensionDir)) {
+      copyOptions.push({
+        from: opts.extensionDir,
+        to: "@vtj/extension",
+        emptyDir: true
+      });
+    }
+    if (copyOptions.length > 0) {
+      plugins.push(cli.copyPlugin(copyOptions));
+    }
+  }
+  if (opts.server) {
+    plugins.push(apiServerPlugin(opts));
+    const staticOptions = [];
+    if (node.pathExistsSync(proPath)) {
+      staticOptions.push({
+        path: `${opts.staticBase}${CLIENT_DIR}`,
+        dir: proPath
+      });
+    }
+    if (node.pathExistsSync(materialsPath1)) {
+      staticOptions.push({
+        path: `${opts.staticBase}@vtj/materials`,
+        dir: materialsPath1
+      });
+    } else if (node.pathExistsSync(materialsPath2)) {
+      staticOptions.push({
+        path: `${opts.staticBase}@vtj/materials`,
+        dir: materialsPath2
+      });
+    } else {
+      console.warn(
+        "\n @vtj/materials is not installed, please install it first.\n"
+      );
+    }
+    materialDirs.forEach((dir) => {
+      staticOptions.push({
+        path: `${opts.staticBase}@vtj/materials`,
+        dir
+      });
+    });
+    if (opts.extensionDir && node.pathExistsSync(opts.extensionDir)) {
+      staticOptions.push({
+        path: `${opts.staticBase}@vtj/extension`,
+        dir: opts.extensionDir
+      });
+    }
+    if (staticOptions.length > 0) {
+      plugins.push(cli.staticPlugin(staticOptions));
+    }
+  }
+  if (opts.presetPlugins && opts.presetPlugins.length) {
+    const { copies, staticDirs } = parsePresetPlugins(opts);
+    if (copies.length) {
+      plugins.push(cli.copyPlugin(copies));
+    }
+    if (staticDirs.length) {
+      plugins.push(cli.staticPlugin(staticDirs));
+    }
+  }
+  if (!!opts.link) {
+    plugins.push(linkPlugin(opts));
+  }
+  if (opts.hm) {
+    plugins.push(hmPlugin(opts));
+  }
+  return plugins;
+}
+
+exports.createDevTools = createDevTools;
+exports.parsePresetPlugins = parsePresetPlugins;