@vtj/local 0.7.33 → 0.8.0

package/dist/controller.d.ts

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

package/dist/controller.mjs

@@ -1,5 +1,7 @@
+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");
@@ -68,19 +70,58 @@ const controller = {
   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) => {
+export const router = async (req, opts) => {
   const body = req.body || {};
-  const handler = controller[body.type] || controller.notMatch;
-  try {
-    return await handler(body);
-  } catch (e) {
-    const info = {
-      input: body,
-      error: e
-    };
-    await service.saveLogs(info);
-    return fail("\u5F02\u5E38\u9519\u8BEF", e);
+  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: e
+      };
+      await service.saveLogs(info);
+      return fail("\u5F02\u5E38\u9519\u8BEF", e);
+    }
   }
 };

package/dist/plugin.d.ts

@@ -4,11 +4,13 @@ export interface DevToolsOptions {
     copy: boolean;
     server: boolean;
     staticBase: string;
+    staticDir: string;
     link: boolean | string;
     linkOptions: LinkOptions | null;
     vtjDir: string;
     packagesDir: string;
     devMode: boolean;
+    uploader: string;
     hm?: string;
 }
 export interface LinkOptions {

package/dist/plugin.mjs

@@ -13,7 +13,7 @@ const setApis = (server, options) => {
   server.middlewares.use(async (req, res, next) => {
     const reqUrl = req.url || "";
     if (reqUrl.startsWith(options.baseURL)) {
-      const data = await router(req);
+      const data = await router(req, options);
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify(data));
     } else {
@@ -144,11 +144,13 @@ export function createDevTools(options = {}) {
     copy: true,
     server: true,
     staticBase: "/",
+    staticDir: "public",
     link: true,
     linkOptions: null,
     vtjDir: ".vtj",
     packagesDir: "../../packages",
     devMode: false,
+    uploader: "/uploader.json",
     hm: "42f2469b4aa27c3f8978f634c0c19d24",
     ...options
   };

package/dist/repository/index.d.ts

@@ -1,2 +1,3 @@
 export * from './json';
 export * from './vue';
+export * from './static';

package/dist/repository/index.mjs

@@ -1,2 +1,3 @@
 export * from "./json.mjs";
 export * from "./vue.mjs";
+export * from "./static.mjs";

package/dist/repository/static.d.ts

@@ -0,0 +1,17 @@
+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[];
+}

package/dist/repository/static.mjs

@@ -0,0 +1,93 @@
+import { resolve, join } from "path";
+import { pathExistsSync, removeSync, readdirSync, moveSync } from "@vtj/node";
+export class StaticRepository {
+  constructor(options) {
+    this.options = options;
+    this.path = resolve(this.options.staticDir, this.options.vtjDir);
+  }
+  path;
+  exist(name) {
+    const filePath = join(this.path, name);
+    return pathExistsSync(filePath);
+  }
+  remove(name) {
+    const filePath = join(this.path, name);
+    if (pathExistsSync(filePath)) {
+      removeSync(filePath);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    if (pathExistsSync(this.path)) {
+      removeSync(this.path);
+      return true;
+    }
+    return false;
+  }
+  getAllFiles() {
+    if (pathExistsSync(this.path)) {
+      const files = readdirSync(this.path) || [];
+      return files.map((name) => {
+        return {
+          filename: name,
+          filepath: 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 = join(this.path, file.originalFilename);
+        if (pathExistsSync(filePath)) {
+          isExists = true;
+          result.push({
+            filename: file.originalFilename,
+            filepath: join(
+              this.options.staticBase,
+              this.options.vtjDir,
+              file.originalFilename
+            ).replace(/\\/g, "/")
+          });
+          break;
+        }
+      }
+    }
+    if (isExists) {
+      for (let file of files) {
+        if (file.filepath) {
+          if (pathExistsSync(file.filepath)) {
+            removeSync(file.filepath);
+          }
+        }
+      }
+    }
+    return isExists ? result : false;
+  }
+  save(files) {
+    const result = [];
+    for (let file of files) {
+      if (file.filepath && file.originalFilename) {
+        const filePath = join(this.path, file.originalFilename);
+        moveSync(file.filepath, filePath, { overwrite: true });
+        result.push({
+          filename: file.originalFilename,
+          filepath: join(
+            this.options.staticBase,
+            this.options.vtjDir,
+            file.originalFilename
+          ).replace(/\\/g, "/")
+        });
+      }
+    }
+    return result;
+  }
+}

package/dist/service.d.ts

@@ -1,5 +1,7 @@
 import { type ProjectSchema, type BlockSchema, type HistorySchema, type HistoryItem, type MaterialDescription, type PageFile, type BlockFile } from '@vtj/core';
+import formidable from 'formidable';
 import { type ApiRequest } from './shared';
+import { type StaticRepositoryOptions } from './repository';
 export declare function notMatch(_req: ApiRequest): Promise<import("./shared").ApiResponse>;
 export declare function saveLogs(e: any): Promise<boolean>;
 export declare function init(): Promise<import("./shared").ApiResponse>;
@@ -19,3 +21,7 @@ export declare function publish(project: ProjectSchema): Promise<import("./share
 export declare function genVueContent(project: ProjectSchema, dsl: BlockSchema): Promise<import("./shared").ApiResponse>;
 export declare function createRawPage(file: PageFile): Promise<import("./shared").ApiResponse>;
 export declare function removeRawPage(id: string): Promise<import("./shared").ApiResponse>;
+export declare function uploadStaticFiles(files: formidable.File[], options: StaticRepositoryOptions): Promise<import("./shared").ApiResponse>;
+export declare function removeStaticFile(filename: string, options: StaticRepositoryOptions): Promise<import("./shared").ApiResponse>;
+export declare function getStaticFiles(options: StaticRepositoryOptions): Promise<import("./shared").ApiResponse>;
+export declare function clearStaticFiles(options: StaticRepositoryOptions): Promise<import("./shared").ApiResponse>;

package/dist/service.mjs

@@ -5,7 +5,11 @@ import { resolve } from "path";
 import { readJsonSync, upperFirstCamelCase, timestamp } from "@vtj/node";
 import { generator, createEmptyPage } from "@vtj/coder";
 import { fail, success } from "./shared.mjs";
-import { JsonRepository, VueRepository } from "./repository/index.mjs";
+import {
+  JsonRepository,
+  VueRepository,
+  StaticRepository
+} from "./repository/index.mjs";
 export async function notMatch(_req) {
   return fail("\u627E\u4E0D\u5230\u5904\u7406\u7A0B\u5E8F");
 }
@@ -132,7 +136,9 @@ export async function publish(project) {
     Object.entries(materials)
   );
   for (const block of blocks) {
-    await publishFile(project, block, componentMap);
+    if (!block.fromType || block.fromType === "Schema") {
+      await publishFile(project, block, componentMap);
+    }
   }
   for (const page of pages) {
     if (!page.raw) {
@@ -161,3 +167,25 @@ export async function removeRawPage(id) {
   repository.remove(id);
   return success(true);
 }
+export 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);
+}
+export async function removeStaticFile(filename, options) {
+  const repository = new StaticRepository(options);
+  const ret = repository.remove(filename);
+  return ret ? success(true) : fail("\u5220\u9664\u5931\u8D25");
+}
+export async function getStaticFiles(options) {
+  const repository = new StaticRepository(options);
+  return success(repository.getAllFiles());
+}
+export async function clearStaticFiles(options) {
+  const repository = new StaticRepository(options);
+  return success(repository.clear());
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vtj/local",
   "private": false,
-  "version": "0.7.33",
+  "version": "0.8.0",
   "type": "module",
   "scripts": {
     "build": "unbuild",
@@ -10,15 +10,17 @@
     "coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@vtj/coder": "^0.7.33",
-    "@vtj/core": "^0.7.33",
-    "@vtj/node": "^0.7.8"
+    "@vtj/coder": "^0.8.0",
+    "@vtj/core": "^0.8.0",
+    "@vtj/node": "^0.8.0",
+    "formidable": "~3.5.1"
   },
   "devDependencies": {
-    "@vtj/cli": "^0.7.21",
+    "@types/formidable": "~3.4.5",
+    "@vtj/cli": "^0.8.0",
     "unbuild": "~2.0.0",
     "vite": "~5.2.6",
-    "vitest": "~1.4.0"
+    "vitest": "~1.5.0"
   },
   "exports": {
     ".": {
@@ -34,7 +36,7 @@
   "files": [
     "dist"
   ],
-  "gitHead": "f8b4d10016f55e54c634f472fde12760d512e829",
+  "gitHead": "911c3a0e2bb60548affe5dcf5a496577809d63b8",
   "publishConfig": {
     "access": "public"
   }