@vtj/local 0.9.30 → 0.10.1-alpha.0

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@vtj/local",
   "private": false,
-  "version": "0.9.30",
+  "version": "0.10.1-alpha.0",
   "type": "module",
   "dependencies": {
     "formidable": "~3.5.1",
-    "@vtj/coder": "~0.9.30",
-    "@vtj/core": "~0.9.30",
-    "@vtj/node": "~0.9.6"
+    "@vtj/coder": "~0.10.1-alpha.0",
+    "@vtj/node": "~0.10.0",
+    "@vtj/core": "~0.10.1-alpha.0",
+    "@vtj/parser": "~0.10.1-alpha.0"
   },
   "devDependencies": {
     "@types/formidable": "~3.4.5",
     "unbuild": "~2.0.0",
     "vite": "~6.0.6",
-    "vitest": "~2.1.1",
-    "@vtj/cli": "~0.9.8"
+    "@vtj/cli": "~0.10.0"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.mjs"
+      "require": "./dist/index.cjs"
     },
     "./*": "./*"
   },
-  "main": "./dist/index.mjs",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [

package/dist/controller.d.ts

@@ -1,6 +0,0 @@
-import { type ApiRequest, type ApiResponse } from './shared';
-import type { DevToolsOptions } from './plugin';
-export interface Controller {
-    [index: string]: (req: ApiRequest, opts: DevToolsOptions) => Promise<ApiResponse>;
-}
-export declare const router: (req: any, opts: DevToolsOptions) => Promise<ApiResponse>;

package/dist/controller.mjs

@@ -1,130 +0,0 @@
-import formidable from "formidable";
-import { fail } from "./shared.mjs";
-import * as service from "./service.mjs";
-import { resolve } from "path";
-const controller = {
-  notMatch: async (_req) => {
-    return fail("\u627E\u4E0D\u5230\u5904\u7406\u7A0B\u5E8F");
-  },
-  getExtension: service.getExtension,
-  init: service.init,
-  saveProject: async (req) => {
-    const project = req.data;
-    return service.saveProject(project);
-  },
-  saveFile: async (req) => {
-    const file = req.data;
-    return service.saveFile(file);
-  },
-  getFile: async (req) => {
-    const id = req.data;
-    return service.getFile(id);
-  },
-  removeFile: async (req) => {
-    const id = req.data;
-    return service.removeFile(id);
-  },
-  getHistory: async (req) => {
-    const id = req.data;
-    return service.getHistory(id);
-  },
-  saveHistory: async (req) => {
-    const file = req.data;
-    return service.saveHistory(file);
-  },
-  removeHistory: async (req) => {
-    const id = req.data;
-    return service.removeHistory(id);
-  },
-  getHistoryItem: async (req) => {
-    const { fId, id } = req.data || {};
-    return service.getHistoryItem(fId, id);
-  },
-  saveHistoryItem: async (req) => {
-    const { fId, item } = req.data || {};
-    return service.saveHistoryItem(fId, item);
-  },
-  removeHistoryItem: async (req) => {
-    const { fId, ids = [] } = req.data || {};
-    return service.removeHistoryItem(fId, ids);
-  },
-  saveMaterials: async (req) => {
-    const { project, materials } = req.data || {};
-    return service.saveMaterials(project, materials);
-  },
-  publishFile: async (req) => {
-    const { project, file } = req.data || {};
-    return service.publishFile(project, file);
-  },
-  publish: async (req) => {
-    const project = req.data || {};
-    return service.publish(project);
-  },
-  genVueContent: async (req) => {
-    const { project, dsl } = req.data || {};
-    return service.genVueContent(project, dsl);
-  },
-  createRawPage: async (req) => {
-    const file = req.data;
-    return service.createRawPage(file);
-  },
-  removeRawPage: async (req) => {
-    const id = req.data;
-    return service.removeRawPage(id);
-  },
-  getStaticFiles: async (_req, opts) => {
-    return service.getStaticFiles(opts);
-  },
-  removeStaticFile: async (req, opts) => {
-    const name = req.data?.name;
-    return service.removeStaticFile(name, opts);
-  },
-  clearStaticFiles: async (_req, opts) => {
-    return service.clearStaticFiles(opts);
-  },
-  uploader: async (req, opts) => {
-    if (!opts) return fail("\u5F02\u5E38\u9519\u8BEF");
-    const uploadDir = resolve(opts.staticDir, opts.vtjDir);
-    const form = formidable({
-      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 = service.uploadStaticFiles(tempFiles, opts);
-        reslove(result);
-      });
-    });
-  }
-};
-export const router = async (req, opts) => {
-  const body = req.body || {};
-  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 service.saveLogs(info);
-      return fail("\u5F02\u5E38\u9519\u8BEF", e?.message, e?.stack);
-    }
-  }
-};

package/dist/plugin.mjs

@@ -1,321 +0,0 @@
-import {
-  copyPlugin,
-  staticPlugin
-} from "@vtj/cli";
-import { pathExistsSync, readJsonSync } from "@vtj/node";
-import { join, resolve } from "path";
-import bodyParser from "body-parser";
-import { router } from "./controller.mjs";
-import { CLIENT_DIR } from "./shared.mjs";
-const setApis = (server, options) => {
-  server.middlewares.use((req, res, next) => {
-    const reqUrl = req.url || "";
-    if (reqUrl.startsWith(options.baseURL)) {
-      bodyParser.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 = join(root, options.vtjDir);
-      const packagesDir = join(root, options.packagesDir);
-      const devAlias = options.devMode && process.env.NODE_ENV === "development" ? {
-        "@vtj/ui/dist/style.css": join(
-          packagesDir,
-          "ui/src/style/index.scss"
-        ),
-        "@vtj/icons/dist/style.css": join(
-          packagesDir,
-          "icons/src/style.scss"
-        ),
-        "@vtj/designer/dist/style.css": join(
-          packagesDir,
-          "designer/src/style/index.scss"
-        ),
-        "@vtj/base": join(packagesDir, "base/src"),
-        "@vtj/utils": join(packagesDir, "utils/src/index.ts"),
-        "@vtj/icons/svg": join(packagesDir, "icons/dist/svg.ts"),
-        "@vtj/icons": join(packagesDir, "icons/src"),
-        "@vtj/ui": join(packagesDir, "ui/src"),
-        "@vtj/charts": join(packagesDir, "charts/src"),
-        "@vtj/core": join(packagesDir, "core/src"),
-        "@vtj/designer": join(packagesDir, "designer/src"),
-        "@vtj/renderer": join(packagesDir, "renderer/src"),
-        "@vtj/coder": join(packagesDir, "coder/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
-          }
-        };
-      }
-    }
-  };
-};
-export function parsePresetPlugins(options) {
-  const {
-    presetPlugins = [],
-    pluginNodeModulesDir = "node_modules",
-    staticBase
-  } = options;
-  const pkg = readJsonSync(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 = join(pluginNodeModulesDir, dep, "dist");
-    if (pathExistsSync(dist)) {
-      copies.push({
-        from: dist,
-        to: "@vtj/plugins",
-        emptyDir: false
-      });
-      staticDirs.push({
-        path: `${staticBase}@vtj/plugins`,
-        dir: dist
-      });
-    }
-  }
-  return {
-    copies,
-    staticDirs
-  };
-}
-export 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 (pathExistsSync(materialsPath1)) {
-      copyOptions.push({
-        from: materialsPath1,
-        to: "@vtj/materials",
-        emptyDir: true
-      });
-    } else if (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 && pathExistsSync(opts.extensionDir)) {
-      copyOptions.push({
-        from: opts.extensionDir,
-        to: "@vtj/extension",
-        emptyDir: true
-      });
-    }
-    if (copyOptions.length > 0) {
-      plugins.push(copyPlugin(copyOptions));
-    }
-  }
-  if (opts.server) {
-    plugins.push(apiServerPlugin(opts));
-    const staticOptions = [];
-    if (pathExistsSync(proPath)) {
-      staticOptions.push({
-        path: `${opts.staticBase}${CLIENT_DIR}`,
-        dir: proPath
-      });
-    }
-    if (pathExistsSync(materialsPath1)) {
-      staticOptions.push({
-        path: `${opts.staticBase}@vtj/materials`,
-        dir: materialsPath1
-      });
-    } else if (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 && pathExistsSync(opts.extensionDir)) {
-      staticOptions.push({
-        path: `${opts.staticBase}@vtj/extension`,
-        dir: opts.extensionDir
-      });
-    }
-    if (staticOptions.length > 0) {
-      plugins.push(staticPlugin(staticOptions));
-    }
-  }
-  if (opts.presetPlugins && opts.presetPlugins.length) {
-    const { copies, staticDirs } = parsePresetPlugins(opts);
-    if (copies.length) {
-      plugins.push(copyPlugin(copies));
-    }
-    if (staticDirs.length) {
-      plugins.push(staticPlugin(staticDirs));
-    }
-  }
-  if (!!opts.link) {
-    plugins.push(linkPlugin(opts));
-  }
-  if (opts.hm) {
-    plugins.push(hmPlugin(opts));
-  }
-  return plugins;
-}

package/dist/repository/index.d.ts

@@ -1,4 +0,0 @@
-export * from './json';
-export * from './vue';
-export * from './static';
-export * from './plugins';

package/dist/repository/index.mjs

@@ -1,4 +0,0 @@
-export * from "./json.mjs";
-export * from "./vue.mjs";
-export * from "./static.mjs";
-export * from "./plugins.mjs";

package/dist/repository/json.d.ts

@@ -1,9 +0,0 @@
-export declare class JsonRepository {
-    private path;
-    constructor(path: string);
-    exist(name: string): any;
-    save(name: string, json: any): boolean;
-    get(name: string): any;
-    remove(name: string): boolean;
-    clear(): boolean;
-}

package/dist/repository/json.mjs

@@ -1,52 +0,0 @@
-import { resolve, join } from "path";
-import {
-  writeJsonSync,
-  pathExistsSync,
-  readJsonSync,
-  removeSync,
-  ensureFileSync
-} from "@vtj/node";
-export class JsonRepository {
-  path;
-  constructor(path) {
-    this.path = resolve(".vtj", path);
-  }
-  exist(name) {
-    const filePath = join(this.path, `${name}.json`);
-    return pathExistsSync(filePath);
-  }
-  save(name, json) {
-    const filePath = join(this.path, `${name}.json`);
-    if (!this.exist(name)) {
-      ensureFileSync(filePath);
-    }
-    writeJsonSync(filePath, json, {
-      spaces: 2,
-      EOL: "\n"
-    });
-    return true;
-  }
-  get(name) {
-    const filePath = join(this.path, `${name}.json`);
-    if (pathExistsSync(filePath)) {
-      return readJsonSync(filePath);
-    } else {
-      return void 0;
-    }
-  }
-  remove(name) {
-    const filePath = join(this.path, `${name}.json`);
-    if (pathExistsSync(filePath)) {
-      removeSync(filePath);
-      return true;
-    }
-    return false;
-  }
-  clear() {
-    if (pathExistsSync(this.path)) {
-      removeSync(this.path);
-      return true;
-    }
-    return false;
-  }
-}

package/dist/repository/plugins.d.ts

@@ -1,10 +0,0 @@
-import { type BlockFile } from '@vtj/core';
-import type { DevToolsOptions } from '../plugin';
-export declare class PluginRepository {
-    private pkg;
-    private opts;
-    private deps;
-    constructor(pkg: any, opts: DevToolsOptions);
-    getName(dep: string): Capitalize<string>;
-    getPlugins(): BlockFile[];
-}

package/dist/repository/plugins.mjs

@@ -1,67 +0,0 @@
-import { join } from "path";
-import {
-  pathExistsSync,
-  readdirSync,
-  readJsonSync,
-  upperFirstCamelCase
-} from "@vtj/node";
-export class PluginRepository {
-  constructor(pkg, opts) {
-    this.pkg = pkg;
-    this.opts = opts;
-    const { devDependencies, dependencies } = pkg || {};
-    const { presetPlugins } = opts;
-    this.deps = Object.keys({ ...devDependencies, ...dependencies }).filter(
-      (name) => presetPlugins.some((regex) => name.startsWith(regex))
-    );
-  }
-  deps = [];
-  getName(dep) {
-    const { presetPlugins } = this.opts;
-    let name = dep;
-    for (const regex of presetPlugins) {
-      name = name.replace(regex, "x-");
-    }
-    return 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 = join(pluginNodeModulesDir, dep, "dist");
-      if (pathExistsSync(dist)) {
-        const pkg = readJsonSync(
-          join(pluginNodeModulesDir, dep, "package.json")
-        );
-        const files = 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 = 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;
-  }
-}

package/dist/repository/static.d.ts

@@ -1,17 +0,0 @@
-import formidable from 'formidable';
-export interface StaticRepositoryOptions {
-    staticBase: string;
-    staticDir: string;
-    vtjDir: string;
-}
-export declare class StaticRepository {
-    private options;
-    private path;
-    constructor(options: StaticRepositoryOptions);
-    exist(name: string): any;
-    remove(name: string): boolean;
-    clear(): boolean;
-    getAllFiles(): any;
-    validate(files: formidable.File[]): false | never[];
-    save(files: formidable.File[]): never[];
-}