@vtj/local 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 陈华春
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/controller.d.ts

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

package/dist/controller.mjs

@@ -0,0 +1,74 @@
+import { fail } from "./shared.mjs";
+import * as service from "./service.mjs";
+const controller = {
+  notMatch: async (_req) => {
+    return fail("\u627E\u4E0D\u5230\u5904\u7406\u7A0B\u5E8F");
+  },
+  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);
+  },
+  getRaw: async (req) => {
+    const { project, dsl } = req.data || {};
+    return service.getRaw(project, dsl);
+  }
+};
+export const router = async (req) => {
+  const body = req.body || {};
+  const handler = controller[body.type] || controller.notMatch;
+  try {
+    return await handler(body);
+  } catch (e) {
+    await service.saveLogs(e);
+    return fail("\u5F02\u5E38\u9519\u8BEF", e);
+  }
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './plugin';

package/dist/index.mjs

@@ -0,0 +1 @@
+export * from "./plugin.mjs";

package/dist/plugin.d.ts

@@ -0,0 +1,11 @@
+import { type Plugin } from 'vite';
+export interface DevPluginOptions {
+    baseURL: string;
+    copy: boolean;
+    server: boolean;
+    link: boolean | string;
+    vtjDir: string;
+    packagesDir: string;
+    devMode: boolean;
+}
+export declare function createDevPlugin(options?: Partial<DevPluginOptions>): Plugin<any>[];

package/dist/plugin.mjs

@@ -0,0 +1,177 @@
+import {
+  copyPlugin,
+  staticPlugin
+} from "@vtj/cli";
+import { pathExistsSync } from "@vtj/node";
+import { join } from "path";
+import bodyParser from "body-parser";
+import { router } from "./controller.mjs";
+const setApis = (server, options) => {
+  server.middlewares.use(
+    bodyParser.json({ type: "application/json", limit: "50000kb" })
+  );
+  server.middlewares.use(async (req, res, next) => {
+    const reqUrl = req.url || "";
+    if (reqUrl.startsWith(options.baseURL)) {
+      const data = await router(req);
+      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) {
+  let config;
+  return {
+    name: "vtj-link-plugin",
+    apply: "serve",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    transformIndexHtml(html) {
+      if (html.includes("VTJ-LINK")) {
+        return html;
+      }
+      if (options.link) {
+        const link = typeof options.link === "string" ? options.link : "@vtj/pro/link.js";
+        const url = `${config.base}${link}`;
+        return html.replace(
+          /<\/body>/,
+          `<script src="${url}"><\/script></body>`
+        );
+      }
+      return html;
+    }
+  };
+};
+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": join(packagesDir, "icons/src"),
+        "@vtj/ui": join(packagesDir, "ui/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) {
+        config.resolve.alias = Object.assign(config.resolve.alias || {}, {
+          $vtj: vtjDir,
+          ...devAlias
+        });
+      } else {
+        config.resolve = {
+          alias: {
+            $vtj: vtjDir,
+            ...devAlias
+          }
+        };
+      }
+    }
+  };
+};
+export function createDevPlugin(options = {}) {
+  const opts = {
+    baseURL: "/vtj/local/api",
+    copy: true,
+    server: true,
+    link: true,
+    vtjDir: ".vtj",
+    packagesDir: "../../packages",
+    devMode: false,
+    ...options
+  };
+  const plugins = [aliasPlugin(opts)];
+  const proPath = "node_modules/@vtj/pro/dist";
+  const materialsPath1 = "node_modules/@vtj/materials/dist";
+  const materialsPath2 = "node_modules/@vtj/pro/" + materialsPath1;
+  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"
+      );
+    }
+    if (copyOptions.length > 0) {
+      plugins.push(copyPlugin(copyOptions));
+    }
+  }
+  if (opts.server) {
+    plugins.push(apiServerPlugin(opts));
+    const staticOptions = [];
+    if (pathExistsSync(proPath)) {
+      staticOptions.push({
+        path: "/@vtj/pro",
+        dir: proPath
+      });
+    }
+    if (pathExistsSync(materialsPath1)) {
+      staticOptions.push({
+        path: "/@vtj/materials",
+        dir: materialsPath1
+      });
+    } else if (pathExistsSync(materialsPath2)) {
+      staticOptions.push({
+        path: "/@vtj/materials",
+        dir: materialsPath2
+      });
+    } else {
+      console.warn(
+        "\n @vtj/materials is not installed, please install it first.\n"
+      );
+    }
+    if (staticOptions.length > 0) {
+      plugins.push(staticPlugin(staticOptions));
+    }
+  }
+  if (!!opts.link) {
+    plugins.push(linkPlugin(opts));
+  }
+  return plugins;
+}

package/dist/service.d.ts

@@ -0,0 +1,19 @@
+import { type ProjectSchema, type BlockSchema, type HistorySchema, type HistoryItem, type MaterialDescription, type PageFile, type BlockFile } from '@vtj/core';
+import { type ApiRequest } from './shared';
+export declare function notMatch(_req: ApiRequest): Promise<import("./shared").ApiResponse>;
+export declare function saveLogs(e: any): Promise<void>;
+export declare function init(): Promise<import("./shared").ApiResponse>;
+export declare function saveProject(project: ProjectSchema): Promise<import("./shared").ApiResponse>;
+export declare function saveFile(file: BlockSchema): Promise<import("./shared").ApiResponse>;
+export declare function getFile(id: string): Promise<import("./shared").ApiResponse>;
+export declare function removeFile(id: string): Promise<import("./shared").ApiResponse>;
+export declare function getHistory(id: string): Promise<import("./shared").ApiResponse>;
+export declare function saveHistory(file: HistorySchema): Promise<import("./shared").ApiResponse>;
+export declare function removeHistory(id: string): Promise<import("./shared").ApiResponse>;
+export declare function getHistoryItem(fId: string, id: string): Promise<import("./shared").ApiResponse>;
+export declare function saveHistoryItem(fId: string, item: HistoryItem): Promise<import("./shared").ApiResponse>;
+export declare function removeHistoryItem(fId: string, ids: string[]): Promise<import("./shared").ApiResponse>;
+export declare function saveMaterials(project: ProjectSchema, materials: Record<string, MaterialDescription>): Promise<import("./shared").ApiResponse>;
+export declare function publishFile(project: ProjectSchema, file: PageFile | BlockFile, componentMap?: Map<string, MaterialDescription>): Promise<import("./shared").ApiResponse>;
+export declare function publish(project: ProjectSchema): Promise<import("./shared").ApiResponse>;
+export declare function getRaw(project: ProjectSchema, dsl: BlockSchema): Promise<import("./shared").ApiResponse>;

package/dist/service.mjs

@@ -0,0 +1,198 @@
+import {
+  ProjectModel
+} from "@vtj/core";
+import { resolve } from "path";
+import {
+  readJsonSync,
+  pathExistsSync,
+  writeJsonSync,
+  ensureFileSync,
+  removeSync,
+  outputFileSync,
+  upperFirstCamelCase,
+  timestamp
+} from "@vtj/node";
+import { generator } from "@vtj/coder";
+import { fail, success } from "./shared.mjs";
+const root = resolve("./");
+const vtjDir = resolve(".vtj");
+const getProjectFilePath = (_name) => {
+  return resolve(vtjDir, "project.json");
+};
+const getMaterialsFilePath = (_name) => {
+  return resolve(vtjDir, "materials.json");
+};
+const getFilePath = (id) => {
+  return resolve(vtjDir, `files/${id}.json`);
+};
+const getHistoryFilePath = (id) => {
+  return resolve(vtjDir, `histories/${id}.json`);
+};
+const getHistoryItemFilePath = (fId, id) => {
+  return resolve(vtjDir, `histories/${fId}/${id}.json`);
+};
+const getHistoryItemDir = (fId) => {
+  return resolve(vtjDir, `histories/${fId}`);
+};
+const getRawFilePath = (id) => {
+  return resolve(vtjDir, `raw/${id}.vue`);
+};
+const getLogsDir = () => {
+  return resolve(vtjDir, `logs`);
+};
+export async function notMatch(_req) {
+  return fail("\u627E\u4E0D\u5230\u5904\u7406\u7A0B\u5E8F");
+}
+export async function saveLogs(e) {
+  const name = `error-${timestamp()}.json`;
+  outputFileSync(resolve(getLogsDir(), name), JSON.stringify(e), "utf-8");
+}
+export async function init() {
+  const pkg = readJsonSync(resolve(root, "package.json"));
+  const { name, description } = pkg || {};
+  const filePath = getProjectFilePath(name);
+  let schema = {};
+  if (pathExistsSync(filePath)) {
+    schema = readJsonSync(filePath);
+  }
+  const project = new ProjectModel({
+    ...schema,
+    id: name,
+    name: description || upperFirstCamelCase(name),
+    description
+  });
+  const dsl = project.toDsl();
+  ensureFileSync(filePath);
+  writeJsonSync(filePath, dsl);
+  return success(dsl);
+}
+export async function saveProject(project) {
+  const filePath = getProjectFilePath(project.id);
+  if (pathExistsSync(filePath)) {
+    writeJsonSync(filePath, project);
+    return success(true);
+  } else {
+    return fail("\u9879\u76EE\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+export async function saveFile(file) {
+  const filePath = getFilePath(file.id);
+  if (!pathExistsSync(filePath)) {
+    ensureFileSync(filePath);
+  }
+  writeJsonSync(filePath, file);
+  return success(true);
+}
+export async function getFile(id) {
+  const filePath = getFilePath(id);
+  if (pathExistsSync(filePath)) {
+    const json = readJsonSync(filePath);
+    return success(json);
+  } else {
+    return fail("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+export async function removeFile(id) {
+  const filePath = getFilePath(id);
+  if (pathExistsSync(filePath)) {
+    removeSync(filePath);
+    return success(true);
+  } else {
+    return fail("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+export async function getHistory(id) {
+  const filePath = getHistoryFilePath(id);
+  if (pathExistsSync(filePath)) {
+    const json = readJsonSync(filePath);
+    return success(json);
+  } else {
+    return success({});
+  }
+}
+export async function saveHistory(file) {
+  const filePath = getHistoryFilePath(file.id);
+  if (!pathExistsSync(filePath)) {
+    ensureFileSync(filePath);
+  }
+  writeJsonSync(filePath, file);
+  return success(true);
+}
+export async function removeHistory(id) {
+  const filePath = getHistoryFilePath(id);
+  const dir = getHistoryItemDir(id);
+  if (pathExistsSync(filePath)) {
+    removeSync(filePath);
+    removeSync(dir);
+    return success(true);
+  } else {
+    return fail("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+export async function getHistoryItem(fId, id) {
+  const filePath = getHistoryItemFilePath(fId, id);
+  if (pathExistsSync(filePath)) {
+    const json = readJsonSync(filePath);
+    return success(json);
+  } else {
+    return fail("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+}
+export async function saveHistoryItem(fId, item) {
+  const filePath = getHistoryItemFilePath(fId, item.id);
+  if (!pathExistsSync(filePath)) {
+    ensureFileSync(filePath);
+  }
+  writeJsonSync(filePath, item);
+  return success(true);
+}
+export async function removeHistoryItem(fId, ids) {
+  ids.forEach((id) => {
+    const filePath = getHistoryItemFilePath(fId, id);
+    removeSync(filePath);
+  });
+  return success(true);
+}
+export async function saveMaterials(project, materials) {
+  const filePath = getMaterialsFilePath(project.id);
+  ensureFileSync(filePath);
+  writeJsonSync(filePath, materials);
+  return success(true);
+}
+export async function publishFile(project, file, componentMap) {
+  const materialsPath = getMaterialsFilePath(project.id);
+  const materials = await readJsonSync(materialsPath);
+  componentMap = componentMap || new Map(Object.entries(materials));
+  const filePath = getFilePath(file.id);
+  const dsl = readJsonSync(filePath);
+  const content = await generator(dsl, componentMap, project.dependencies);
+  const rawPath = getRawFilePath(file.id);
+  outputFileSync(rawPath, content, "utf-8");
+  return success(true);
+}
+export async function publish(project) {
+  const { pages = [], blocks = [] } = project;
+  const materialsPath = getMaterialsFilePath(project.id);
+  const materials = await readJsonSync(materialsPath);
+  const componentMap = new Map(
+    Object.entries(materials)
+  );
+  for (const block of blocks) {
+    await publishFile(project, block, componentMap);
+  }
+  for (const page of pages) {
+    if (!page.raw) {
+      await publishFile(project, page, componentMap);
+    }
+  }
+  return success(true);
+}
+export async function getRaw(project, dsl) {
+  const materialsPath = getMaterialsFilePath(project.id);
+  const materials = await readJsonSync(materialsPath);
+  const componentMap = new Map(
+    Object.entries(materials)
+  );
+  const content = await generator(dsl, componentMap, project.dependencies);
+  return success(content);
+}

package/dist/shared.d.ts

@@ -0,0 +1,16 @@
+export interface ApiRequest {
+    type: string;
+    data: any;
+}
+export interface ApiResponse {
+    code: number;
+    msg: string;
+    data: any;
+    success: boolean;
+}
+export declare enum Result {
+    Success = 0,
+    Fail = 1
+}
+export declare const success: (data: any) => ApiResponse;
+export declare const fail: (msg: string, data?: any) => ApiResponse;

package/dist/shared.mjs

@@ -0,0 +1,21 @@
+export var Result = /* @__PURE__ */ ((Result2) => {
+  Result2[Result2["Success"] = 0] = "Success";
+  Result2[Result2["Fail"] = 1] = "Fail";
+  return Result2;
+})(Result || {});
+export const success = (data) => {
+  return {
+    code: 0 /* Success */,
+    msg: "success",
+    data,
+    success: true
+  };
+};
+export const fail = (msg, data = null) => {
+  return {
+    code: 1 /* Fail */,
+    msg,
+    data,
+    success: false
+  };
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@vtj/local",
+  "private": false,
+  "version": "0.7.0",
+  "type": "module",
+  "scripts": {
+    "build": "unbuild",
+    "test": "vitest run",
+    "vitest": "vitest",
+    "coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@vtj/coder": "^0.7.0",
+    "@vtj/core": "^0.7.0",
+    "@vtj/node": "^0.7.0"
+  },
+  "devDependencies": {
+    "@vtj/cli": "^0.7.0",
+    "unbuild": "~2.0.0",
+    "vite": "~5.0.11",
+    "vitest": "~1.2.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.mjs"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "gitHead": "b65d1b19322cbd0721173d094db1b5ece018d980",
+  "publishConfig": {
+    "access": "public"
+  }
+}