@uni-helper/vite-plugin-uni-pages 0.0.7 → 0.1.1

package/dist/index.cjs

@@ -1,293 +1,392 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  VitePluginUniPages: () => VitePluginUniPages,
-  default: () => src_default,
-  definePages: () => definePages
-});
-module.exports = __toCommonJS(src_exports);
-var import_vite3 = require("vite");
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const path = require('path');
+const MagicString = require('magic-string');
+const chokidar = require('chokidar');
+const vite = require('vite');
+const unconfig = require('unconfig');
+const Debug = require('debug');
+const lodashEs = require('lodash-es');
+const fg = require('fast-glob');
+const fs = require('fs');
+const JSON5 = require('json5');
+const yaml = require('yaml');
+const compilerSfc = require('@vue/compiler-sfc');
+
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
 
-// src/utils.ts
-var import_path = require("path");
-var import_vite = require("vite");
-var import_consola = __toESM(require("consola"), 1);
-var isPagePath = (path, options) => {
-  const dirPath = (0, import_path.resolve)(process.cwd(), options.pagesDir);
-  const filter = (0, import_vite.createFilter)(
-    dirPath + "/**/*.(vue|nvue|uvue)",
-    options.exclude
-  );
-  return filter(path);
+const MODULE_ID_VIRTUAL = "virtual:uni-pages";
+const RESOLVED_MODULE_ID_VIRTUAL = `\0${MODULE_ID_VIRTUAL}`;
+const OUTPUT_NAME = "pages.json";
+const FILE_EXTENSIONS = ["vue", "nvue", "uvue"];
+
+function invalidatePagesModule(server) {
+  const { moduleGraph } = server;
+  const mods = moduleGraph.getModulesByFile(RESOLVED_MODULE_ID_VIRTUAL);
+  if (mods) {
+    const seen = /* @__PURE__ */ new Set();
+    mods.forEach((mod) => {
+      moduleGraph.invalidateModule(mod, seen);
+    });
+  }
+}
+const debug = {
+  hmr: Debug("vite-plugin-uni-pages:hmr"),
+  routeBlock: Debug("vite-plugin-uni-pages:routeBlock"),
+  options: Debug("vite-plugin-uni-pages:options"),
+  pages: Debug("vite-plugin-uni-pages:pages"),
+  error: Debug("vite-plugin-uni-pages:error")
 };
-var logger = import_consola.default.create({
-  defaults: {
-    tag: "vite-plugin-uni-pages"
+function extsToGlob(extensions) {
+  return extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0] || "";
+}
+function isTargetFile(path) {
+  const ext = path.split(".").pop();
+  return FILE_EXTENSIONS.includes(ext);
+}
+function isConfigFile(path) {
+  return path.includes("pages.config");
+}
+function mergePageMetaDataArray(pageMetaData) {
+  const pageMetaDataObj = lodashEs.groupBy(pageMetaData, "path");
+  const result = [];
+  for (const path in pageMetaDataObj) {
+    const _pageMetaData = pageMetaDataObj[path];
+    const options = _pageMetaData[0];
+    for (const page of _pageMetaData) {
+      options.style = Object.assign(options.style ?? {}, page.style ?? {});
+      Object.assign(options, page);
+    }
+    result.push(options);
   }
-});
+  return result;
+}
+
+function resolveOptions(userOptions, viteRoot) {
+  const {
+    mergePages = true,
+    dir = "src/pages",
+    outDir = "src",
+    exclude = ["node_modules", ".git", "**/__*__/**"],
+    routeBlockLang = "json5",
+    onBeforeLoadUserConfig = () => {
+    },
+    onAfterLoadUserConfig = () => {
+    },
+    onBeforeScanPages = () => {
+    },
+    onAfterScanPages = () => {
+    },
+    onBeforeMergePageMetaData = () => {
+    },
+    onAfterMergePageMetaData = () => {
+    },
+    onBeforeWriteFile = () => {
+    },
+    onAfterWriteFile = () => {
+    }
+  } = userOptions;
+  const root = viteRoot || slash(process.cwd());
+  const resolvedDirs = resolvePageDirs(dir, root, exclude);
+  const resolvedOptions = {
+    mergePages,
+    dirs: resolvedDirs,
+    outDir,
+    exclude,
+    routeBlockLang,
+    root,
+    onBeforeLoadUserConfig,
+    onAfterLoadUserConfig,
+    onBeforeScanPages,
+    onAfterScanPages,
+    onBeforeMergePageMetaData,
+    onAfterMergePageMetaData,
+    onBeforeWriteFile,
+    onAfterWriteFile
+  };
+  return resolvedOptions;
+}
+function resolvePageDirs(dir, root, exclude) {
+  const dirs = fg.sync(slash(dir), {
+    ignore: exclude,
+    onlyDirectories: true,
+    dot: true,
+    unique: true,
+    cwd: root
+  });
+  return dirs;
+}
 
-// src/constant.ts
-var virtualModuleId = "virtual:uni-pages";
-var resolvedVirtualModuleId = "\0" + virtualModuleId;
+function getPageFiles(path, options) {
+  const { exclude } = options;
+  const ext = extsToGlob(FILE_EXTENSIONS);
+  const files = fg.sync(`**/*.${ext}`, {
+    ignore: exclude,
+    onlyFiles: true,
+    cwd: path
+  });
+  return files;
+}
+function checkPagesJsonFile(path) {
+  if (!fs.existsSync(path))
+    writeFileSync(path, JSON.stringify({ pages: [{ path: "" }] }, null, 2));
+}
+function writeFileSync(path, content) {
+  fs.writeFileSync(path, content, { encoding: "utf-8" });
+}
 
-// src/context/index.ts
-var import_path2 = require("path");
-var import_unconfig = require("unconfig");
-var import_vite2 = require("vite");
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_jsonc_parser = require("jsonc-parser");
-var import_compiler_dom = require("@vue/compiler-dom");
-var import_fs = __toESM(require("fs"), 1);
-var import_defu = require("defu");
-var Context = class {
-  constructor(options) {
-    this.pagesPathInfo = [];
-    this.pagesMeta = [];
-    this.options = options;
-    this.createOrUpdatePagesJSON();
+async function parseSFC(code) {
+  try {
+    return compilerSfc.parse(code, {
+      pad: "space"
+    }).descriptor || compilerSfc.parse({
+      source: code
+    });
+  } catch {
+    throw new Error(
+      `[vite-plugin-uni-pages] Vue3's "@vue/compiler-sfc" is required.`
+    );
+  }
+}
+function parseCustomBlock(block, filePath, options) {
+  const lang = block.lang ?? options.routeBlockLang;
+  debug.routeBlock(`use ${lang} parser`);
+  if (lang === "json5") {
+    try {
+      return JSON5.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON5 format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  } else if (lang === "json") {
+    try {
+      return JSON.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  } else if (lang === "yaml" || lang === "yml") {
+    try {
+      return yaml.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid YAML format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  }
+}
+async function getRouteBlock(path, options) {
+  const content = fs.readFileSync(path, "utf8");
+  const parsedSFC = await parseSFC(content);
+  const blockStr = parsedSFC?.customBlocks.find((b) => b.type === "route");
+  if (!blockStr)
+    return;
+  const result = parseCustomBlock(blockStr, path, options);
+  return result;
+}
+
+class PageContext {
+  constructor(userOptions, viteRoot = process.cwd()) {
+    this.pagesPath = [];
+    this.pageMetaData = [];
+    this.resolvedPagesJSONPath = "";
+    this.rawOptions = userOptions;
+    this.root = slash(viteRoot);
+    debug.options("root", this.root);
+    this.options = resolveOptions(userOptions, this.root);
+    this.resolvedPagesJSONPath = path.join(this.root, this.options.outDir, OUTPUT_NAME);
+    debug.options(this.options);
+  }
+  setLogger(logger) {
+    this.logger = logger;
   }
   async loadUserPagesConfig() {
-    const { config } = await (0, import_unconfig.loadConfig)({
-      sources: [
-        {
-          files: "pages.config"
-        }
-      ],
-      merge: false
-    });
+    const { config } = await unconfig.loadConfig({ sources: [{ files: "pages.config" }] });
     if (!config) {
-      logger.error(
-        "Can't found pages.config, please create pages.config.(ts|mts|cts|js|cjs|mjs|json)"
-      );
+      this.logger?.warn("Can't found pages.config, please create pages.config.(ts|mts|cts|js|cjs|mjs|json)");
       process.exit(-1);
     }
-    logger.debug("Loaded user pages config", config);
-    this.pagesConfig = config;
+    this.pagesGlobConfig = config;
+    debug.options(config);
   }
   async scanPages() {
-    const files = await (0, import_fast_glob.default)("**/*.(vue|nvue|uvue)", {
-      ignore: ["node_modules", ".git", "**/__*__/*", ...this.options.exclude],
-      onlyFiles: true,
-      cwd: (0, import_path2.resolve)(process.cwd(), this.options.pagesDir)
+    const pageDirFiles = this.options.dirs.map((dir) => {
+      const pagesDirPath = slash(path.resolve(this.options.root, dir));
+      const basePath = slash(path.join(this.options.root, this.options.outDir));
+      const files = getPageFiles(pagesDirPath, this.options);
+      debug.pages(dir, files);
+      const pagePaths = files.map((file) => slash(file)).map((file) => ({
+        relativePath: path.relative(basePath, slash(path.resolve(pagesDirPath, file))),
+        absolutePath: slash(path.resolve(pagesDirPath, file))
+      }));
+      return { dir, files: pagePaths };
     });
-    const basePath = (0, import_path2.relative)(
-      (0, import_path2.resolve)(process.cwd(), this.options.outDir),
-      this.options.pagesDir
-    );
-    this.pagesPathInfo = files.map((file) => {
-      return {
-        relative: (0, import_vite2.normalizePath)((0, import_path2.join)(basePath, file)),
-        absolute: (0, import_vite2.normalizePath)(
-          (0, import_path2.resolve)(process.cwd(), this.options.pagesDir, file)
-        )
-      };
-    });
-    logger.debug("Scanned pages dir", this.pagesPathInfo);
+    this.pagesPath = pageDirFiles.map((page) => page.files).flat();
+    debug.pages(this.pagesPath);
+  }
+  setupViteServer(server) {
+    if (this._server === server)
+      return;
+    this._server = server;
+    this.setupWatcher(server.watcher);
   }
-  async parsePage({ relative: relative2, absolute }) {
-    const code = await import_fs.default.promises.readFile(absolute, {
-      encoding: "utf-8"
+  setupWatcher(watcher) {
+    watcher.on("add", async (path2) => {
+      path2 = slash(path2);
+      if (!isTargetFile(path2))
+        return;
+      debug.pages(`File added: ${path2}`);
+      this.updatePagesJSON();
+      this.onUpdate();
     });
-    const t = (0, import_compiler_dom.parse)(code);
-    const path = relative2.replace((0, import_path2.extname)(relative2), "");
-    let pageMeta = {
-      path,
-      type: "page"
-    };
-    t == null ? void 0 : t.children.forEach((v) => {
-      var _a;
-      if (v.type !== 1) {
+    watcher.on("change", async (path2) => {
+      path2 = slash(path2);
+      if (!isTargetFile(path2) && !isConfigFile(path2))
         return;
-      }
-      if (v.tag === "route") {
-        v.props.forEach((prop) => {
-          var _a2;
-          if (prop.type === 6 && prop.name === "type") {
-            pageMeta.type = ((_a2 = prop.value) == null ? void 0 : _a2.content) ?? pageMeta.type;
-          }
-        });
-        const astContent = (_a = v.children) == null ? void 0 : _a[0];
-        if (astContent && astContent.type === 2) {
-          const _pageMeta = (0, import_jsonc_parser.parse)(astContent.content);
-          Object.keys(_pageMeta).forEach((key) => {
-            pageMeta[key] = _pageMeta[key];
-          });
-          pageMeta["path"] = path;
-        }
-      }
+      debug.pages(`File changed: ${path2}`);
+      this.updatePagesJSON();
+      this.onUpdate();
+    });
+    watcher.on("unlink", async (path2) => {
+      path2 = slash(path2);
+      if (!isTargetFile(path2))
+        return;
+      debug.pages(`File removed: ${path2}`);
+      this.updatePagesJSON();
+      this.onUpdate();
     });
-    return pageMeta;
   }
-  async mergePagesMeta() {
-    var _a;
-    const pagesMeta = await Promise.all(
-      (_a = this.pagesPathInfo) == null ? void 0 : _a.map(async (page) => await this.parsePage(page))
-    );
-    const pages = Object.values((0, import_defu.defu)({}, pagesMeta, this.pagesConfig.pages));
-    pages.sort((a) => a.type === "home" ? -1 : 0);
-    this.pagesMeta = pages;
-    logger.debug("merged pages", this.pagesMeta);
+  onUpdate() {
+    if (!this._server)
+      return;
+    invalidatePagesModule(this._server);
+    debug.hmr("Reload generated pages.");
+    this._server.ws.send({
+      type: "full-reload"
+    });
+  }
+  async parsePage(page) {
+    const { relativePath, absolutePath } = page;
+    const routeBlock = await getRouteBlock(absolutePath, this.options);
+    const relativePathWithFileName = relativePath.replace(path.extname(relativePath), "");
+    const pageMetaDatum = { path: vite.normalizePath(relativePathWithFileName), type: "page" };
+    if (routeBlock)
+      Object.assign(pageMetaDatum, routeBlock);
+    return pageMetaDatum;
   }
-  async createOrUpdatePagesJSON() {
-    const outputName = "pages.json";
-    const resolvedOutput = (0, import_vite2.normalizePath)(
-      (0, import_path2.resolve)(process.cwd(), this.options.outDir, outputName)
+  async mergePageMetaData() {
+    const generatedPageMetaData = await Promise.all(
+      this.pagesPath.map(async (page) => await this.parsePage(page))
     );
-    if (!import_fs.default.existsSync(resolvedOutput)) {
-      import_fs.default.writeFileSync(resolvedOutput, `{"pages": [{"path": ""}]}`, {
-        encoding: "utf-8"
-      });
+    const customPageMetaData = this.pagesGlobConfig?.pages || [];
+    if (!this.options.mergePages) {
+      this.pageMetaData = customPageMetaData;
+    } else {
+      if (this.pagesGlobConfig?.pages)
+        this.pageMetaData = mergePageMetaDataArray(generatedPageMetaData.concat(customPageMetaData));
+      else
+        this.pageMetaData = generatedPageMetaData;
     }
+    debug.pages(generatedPageMetaData);
+  }
+  async updatePagesJSON() {
+    checkPagesJsonFile(this.resolvedPagesJSONPath);
     this.options.onBeforeLoadUserConfig(this);
     await this.loadUserPagesConfig();
     this.options.onAfterLoadUserConfig(this);
-    this.options.onBeforeScanPages(this);
-    await this.scanPages();
-    this.options.onAfterScanPages(this);
-    this.options.onBeforeMergePagesMeta(this);
-    await this.mergePagesMeta();
-    this.options.onAfterMergePagesMeta(this);
+    if (this.options.mergePages) {
+      this.options.onBeforeScanPages(this);
+      await this.scanPages();
+      this.options.onAfterScanPages(this);
+    }
+    this.options.onBeforeMergePageMetaData(this);
+    await this.mergePageMetaData();
+    this.options.onAfterMergePageMetaData(this);
     this.options.onBeforeWriteFile(this);
-    import_fs.default.writeFileSync(resolvedOutput, this.pagesJson, {
-      encoding: "utf-8"
-    });
+    const pagesJson = JSON.stringify({ ...this.pagesGlobConfig, pages: this.pageMetaData }, null, 2);
+    writeFileSync(this.resolvedPagesJSONPath, pagesJson);
     this.options.onAfterWriteFile(this);
   }
   async virtualModule() {
-    return `export const pages = ${JSON.stringify(this.pagesMeta)};`;
+    return `export const pages = ${this.resolveRoutes()};`;
   }
-  async pagesConfigSourcePaths() {
-    return await (0, import_fast_glob.default)("pages.config.(ts|mts|cts|js|cjs|mjs|json)", {
-      deep: 0,
-      onlyFiles: true,
-      absolute: true
-    });
+  resolveRoutes() {
+    return JSON.stringify(this.pageMetaData, null, 2);
   }
-  get pagesJson() {
-    return JSON.stringify({
-      ...this.pagesConfig,
-      pages: this.pagesMeta
-    });
-  }
-};
+}
 
-// src/config/index.ts
-function definePages(config) {
+function defineUniPages(config) {
   return config;
 }
 
-// src/index.ts
-function resolveOptions(userOptions) {
-  return {
-    pagesDir: "src/pages",
-    outDir: "src",
-    exclude: [],
-    onBeforeLoadUserConfig: () => {
-    },
-    onAfterLoadUserConfig: () => {
-    },
-    onBeforeScanPages: () => {
-    },
-    onAfterScanPages: () => {
-    },
-    onBeforeMergePagesMeta: () => {
-    },
-    onAfterMergePagesMeta: () => {
-    },
-    onBeforeWriteFile: () => {
-    },
-    onAfterWriteFile: () => {
-    },
-    ...userOptions
-  };
-}
-var VitePluginUniPages = async (userOptions = {}) => {
-  const options = resolveOptions(userOptions);
-  logger.debug("Create uni-pages context with", options);
-  const ctx = new Context(options);
+const VitePluginUniPages = (userOptions = {}) => {
+  let ctx;
+  const resolvedPagesJSONPath = path.join(process.cwd(), userOptions.outDir ?? "src", OUTPUT_NAME);
+  checkPagesJsonFile(resolvedPagesJSONPath);
   return {
     name: "vite-plugin-uni-pages",
     enforce: "pre",
-    async configureServer({ watcher, moduleGraph, ws }) {
-      const pagesConfigSourcePaths = await ctx.pagesConfigSourcePaths();
-      logger.debug("Add watcher", pagesConfigSourcePaths);
-      watcher.add(pagesConfigSourcePaths);
-      const reloadModule = (module2, path = "*") => {
-        if (module2) {
-          moduleGraph.invalidateModule(module2);
-          if (ws) {
-            ws.send({
-              path,
-              type: "full-reload"
-            });
-          }
-        }
-      };
-      const updateVirtualModule = () => {
-        logger.debug("Update virtualModule");
-        const module2 = moduleGraph.getModuleById(resolvedVirtualModuleId);
-        reloadModule(module2);
-      };
-      watcher.on("change", async (path) => {
-        if (pagesConfigSourcePaths.includes((0, import_vite3.normalizePath)(path)) || isPagePath(path, options)) {
-          await ctx.createOrUpdatePagesJSON();
-          updateVirtualModule();
-        }
-      });
-      watcher.on("add", async (path) => {
-        if (isPagePath(path, options)) {
-          await ctx.createOrUpdatePagesJSON();
-          updateVirtualModule();
-        }
-      });
-      watcher.on("unlink", async (path) => {
-        if (isPagePath(path, options)) {
-          await ctx.createOrUpdatePagesJSON();
-          updateVirtualModule();
-        }
-      });
+    async configResolved(config) {
+      ctx = new PageContext(userOptions, config.root);
+      ctx.setLogger(config.logger);
+      ctx.updatePagesJSON();
+      if (config.build.watch && config.command === "build")
+        ctx.setupWatcher(chokidar.watch(ctx.options.dirs));
     },
-    resolveId(id) {
-      if (id === virtualModuleId) {
-        return resolvedVirtualModuleId;
+    async transform(code, id) {
+      if (!/\.vue$/.test(id))
+        return null;
+      const s = new MagicString(code.toString());
+      const routeBlockMatches = s.original.matchAll(/<route[^>]*>([\s\S]*?)<\/route>/g);
+      for (const match of routeBlockMatches) {
+        const index = match.index;
+        const length = match[0].length;
+        s.remove(index, index + length);
       }
+      return s.toString();
+    },
+    configureServer(server) {
+      ctx.setupViteServer(server);
+    },
+    resolveId(id) {
+      if (id === MODULE_ID_VIRTUAL)
+        return RESOLVED_MODULE_ID_VIRTUAL;
     },
     load(id) {
-      if (id === resolvedVirtualModuleId) {
+      if (id === RESOLVED_MODULE_ID_VIRTUAL)
         return ctx.virtualModule();
-      }
     }
   };
 };
-var src_default = VitePluginUniPages;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  VitePluginUniPages,
-  definePages
-});
-//# sourceMappingURL=index.cjs.map
+
+exports.FILE_EXTENSIONS = FILE_EXTENSIONS;
+exports.MODULE_ID_VIRTUAL = MODULE_ID_VIRTUAL;
+exports.OUTPUT_NAME = OUTPUT_NAME;
+exports.PageContext = PageContext;
+exports.RESOLVED_MODULE_ID_VIRTUAL = RESOLVED_MODULE_ID_VIRTUAL;
+exports.VitePluginUniPages = VitePluginUniPages;
+exports.checkPagesJsonFile = checkPagesJsonFile;
+exports.debug = debug;
+exports.default = VitePluginUniPages;
+exports.defineUniPages = defineUniPages;
+exports.extsToGlob = extsToGlob;
+exports.getPageFiles = getPageFiles;
+exports.getRouteBlock = getRouteBlock;
+exports.invalidatePagesModule = invalidatePagesModule;
+exports.isConfigFile = isConfigFile;
+exports.isTargetFile = isTargetFile;
+exports.mergePageMetaDataArray = mergePageMetaDataArray;
+exports.parseCustomBlock = parseCustomBlock;
+exports.parseSFC = parseSFC;
+exports.resolveOptions = resolveOptions;
+exports.resolvePageDirs = resolvePageDirs;
+exports.writeFileSync = writeFileSync;