@uni-helper/vite-plugin-uni-pages 0.3.2 → 0.3.4

package/dist/index.mjs

@@ -1,22 +1,34 @@
-import path, { join, dirname, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
+import path, { join, dirname, resolve, extname } from 'node:path';
 import process from 'node:process';
-import { normalizePath, createLogger } from 'vite';
-import MagicString from 'magic-string';
+import { babelParse, isCallOf } from 'ast-kit';
 import chokidar from 'chokidar';
-import { loadConfig } from 'unconfig';
-import Debug from 'debug';
+import { lightYellow, bold, link, dim } from 'kolorist';
+import MagicString from 'magic-string';
+import { normalizePath, createLogger } from 'vite';
 import { platform } from '@uni-helper/uni-env';
+import { stringify, parse, assign } from 'comment-json';
+import Debug from 'debug';
 import detectIndent from 'detect-indent';
 import detectNewline from 'detect-newline';
-import { parse as parse$1, stringify, assign } from 'comment-json';
-import fs, { existsSync } from 'node:fs';
+import { loadConfig } from 'unconfig';
+import fs, { existsSync, readFileSync as readFileSync$1 } from 'node:fs';
 import { readFile, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
+import fg from 'fast-glob';
+import { createRequire } from 'node:module';
+import vm from 'node:vm';
+import babelGenerator from '@babel/generator';
 import groupBy from 'lodash.groupby';
+import * as ts from 'typescript';
+import * as t from '@babel/types';
+import { parse as parse$2 } from '@vue/compiler-sfc';
 import JSON5 from 'json5';
-import { parse as parse$2 } from 'yaml';
-import { parse } from '@vue/compiler-sfc';
-import fg from 'fast-glob';
+import { parse as parse$1 } from 'yaml';
+
+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 slash(str) {
   return str.replace(/\\/g, "/");
@@ -68,86 +80,6 @@ async function writeDeclaration(ctx, filepath) {
     await writeFile(filepath, code);
 }
 
-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"];
-
-async function parseSFC(code) {
-  try {
-    return parse(code, {
-      pad: "space"
-    }).descriptor || parse({
-      source: code
-    });
-  } catch (error) {
-    throw new Error(`[vite-plugin-uni-pages] Vue3's "@vue/compiler-sfc" is required. 
-Original error: 
-${error}`);
-  }
-}
-function parseCustomBlock(block, filePath, options) {
-  const lang = block.lang ?? options.routeBlockLang;
-  const attr = {
-    type: "page",
-    ...block.attrs
-  };
-  let content;
-  debug.routeBlock(`use ${lang} parser`);
-  if (lang === "json5") {
-    try {
-      content = JSON5.parse(block.content);
-    } catch (err) {
-      throw new Error(
-        `Invalid JSON5 format of <${block.type}> content in ${filePath}
-${err.message}`
-      );
-    }
-  } else if (lang === "jsonc") {
-    try {
-      content = parse$1(block.content);
-    } catch (err) {
-      throw new Error(
-        `Invalid JSONC format of <${block.type}> content in ${filePath}
-${err.message}`
-      );
-    }
-  } else if (lang === "json") {
-    try {
-      content = 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 {
-      content = parse$2(block.content);
-    } catch (err) {
-      throw new Error(
-        `Invalid YAML format of <${block.type}> content in ${filePath}
-${err.message}`
-      );
-    }
-  }
-  return {
-    attr,
-    content: content ?? {}
-  };
-}
-async function getRouteSfcBlock(path) {
-  const content = fs.readFileSync(path, "utf8");
-  const parsedSFC = await parseSFC(content);
-  const blockStr = parsedSFC?.customBlocks.find((b) => b.type === "route");
-  return blockStr;
-}
-async function getRouteBlock(path, blockStr, options) {
-  if (!blockStr)
-    return;
-  return parseCustomBlock(blockStr, path, options);
-}
-
 function invalidatePagesModule(server) {
   const { moduleGraph } = server;
   const mods = moduleGraph.getModulesByFile(RESOLVED_MODULE_ID_VIRTUAL);
@@ -166,20 +98,21 @@ const debug = {
   subPages: Debug("vite-plugin-uni-pages:subPages"),
   error: Debug("vite-plugin-uni-pages:error"),
   cache: Debug("vite-plugin-uni-pages:cache"),
-  declaration: Debug("vite-plugin-uni-pages:declaration")
+  declaration: Debug("vite-plugin-uni-pages:declaration"),
+  definePage: Debug("vite-plugin-uni-pages:definePage")
 };
 function extsToGlob(extensions) {
   return extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0] || "";
 }
-function isTargetFile(path) {
-  const ext = path.split(".").pop();
+function isTargetFile(path2) {
+  const ext = path2.split(".").pop();
   return FILE_EXTENSIONS.includes(ext);
 }
 function mergePageMetaDataArray(pageMetaData) {
   const pageMetaDataObj = groupBy(pageMetaData, "path");
   const result = [];
-  for (const path in pageMetaDataObj) {
-    const _pageMetaData = pageMetaDataObj[path];
+  for (const path2 in pageMetaDataObj) {
+    const _pageMetaData = pageMetaDataObj[path2];
     const options = _pageMetaData[0];
     for (const page of _pageMetaData) {
       options.style = Object.assign(options.style ?? {}, page.style ?? {});
@@ -189,26 +122,64 @@ function mergePageMetaDataArray(pageMetaData) {
   }
   return result;
 }
-function useCachedPages() {
-  const pages = /* @__PURE__ */ new Map();
-  function parseData(block) {
-    return {
-      content: block?.loc.source.trim() ?? "",
-      attr: block?.attrs ?? ""
-    };
+async function execScript(code, filename) {
+  const jsCode = ts.transpileModule(code, {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ESNext
+    }
+  }).outputText;
+  const dir = path.dirname(filename);
+  const vmContext = {
+    require: createRequire(dir),
+    module: {},
+    exports: {},
+    __filename: filename,
+    __dirname: dir
+  };
+  const script = new vm.Script(jsCode);
+  try {
+    script.runInNewContext(vmContext);
+  } catch (error) {
+    throw new Error(`${filename}: ${error.message}`);
   }
-  function setCache(filePath, routeBlock) {
-    pages.set(filePath, stringify(parseData(routeBlock)));
+  const result = vmContext.exports.default || vmContext.exports;
+  if (typeof result === "function") {
+    return Promise.resolve(result());
   }
-  async function hasChanged(filePath, routeBlock) {
-    if (!routeBlock)
-      routeBlock = await getRouteSfcBlock(normalizePath(filePath));
-    return !pages.has(filePath) || stringify(parseData(routeBlock)) !== pages.get(filePath);
+  return Promise.resolve(result);
+}
+function getDefaultExport(expr) {
+  return expr.default === void 0 ? expr : expr.default;
+}
+const babelGenerate = getDefaultExport(babelGenerator);
+
+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, stringify({ pages: [{ path: "" }] }, null, 2));
+    return false;
   }
-  return {
-    setCache,
-    hasChanged
-  };
+  return true;
+}
+function readFileSync(path) {
+  try {
+    return fs.readFileSync(path, { encoding: "utf-8" });
+  } catch {
+    return "";
+  }
+}
+function writeFileSync(path, content) {
+  fs.writeFileSync(path, content, { encoding: "utf-8" });
 }
 
 function resolveOptions(userOptions, viteRoot = process.cwd()) {
@@ -282,32 +253,190 @@ function resolvePageDirs(dir, root, exclude) {
   return dirs;
 }
 
-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 parseCustomBlock(block, filePath, routeBlockLang) {
+  const lang = block.lang ?? routeBlockLang;
+  const attr = {
+    type: "page",
+    ...block.attrs
+  };
+  let content;
+  debug.routeBlock(`use ${lang} parser`);
+  if (lang === "json5") {
+    try {
+      content = JSON5.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON5 format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  } else if (lang === "jsonc") {
+    try {
+      content = parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSONC format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  } else if (lang === "json") {
+    try {
+      content = 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 {
+      content = parse$1(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid YAML format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  }
+  return {
+    attr,
+    content: content ?? {}
+  };
 }
-function checkPagesJsonFile(path) {
-  if (!fs.existsSync(path)) {
-    writeFileSync(path, stringify({ pages: [{ path: "" }] }, null, 2));
-    return false;
+function getRouteSfcBlock(sfc) {
+  return sfc?.customBlocks.find((b) => b.type === "route");
+}
+function getRouteBlock(path, blockStr, routeBlockLang) {
+  if (!blockStr)
+    return;
+  return parseCustomBlock(blockStr, path, routeBlockLang);
+}
+
+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 Page {
+  constructor(ctx, path) {
+    __publicField$1(this, "ctx");
+    __publicField$1(this, "path");
+    __publicField$1(this, "rawOptions", "");
+    __publicField$1(this, "options");
+    this.ctx = ctx;
+    this.path = path;
+  }
+  async getPageMeta(forceUpdate = false) {
+    if (forceUpdate || !this.options) {
+      await this.readPageMeta();
+    }
+    return this.options;
+  }
+  async hasChanged() {
+    const { hasChanged } = await this.readPageMeta();
+    return hasChanged;
+  }
+  async readPageMeta() {
+    try {
+      const { relativePath } = this.path;
+      const { path, ...others } = await this.readPageMetaFromFile();
+      this.options = {
+        path: path ?? normalizePath(relativePath.replace(extname(relativePath), "")),
+        ...others
+      };
+      const raw = this.options ? JSON.stringify(this.options) : "";
+      const hasChanged = this.rawOptions !== raw;
+      this.rawOptions = raw;
+      return {
+        options: this.options,
+        hasChanged
+      };
+    } catch (err) {
+      throw new Error(`Read page options fail in ${this.path.relativePath}
+${err.message}`);
+    }
+  }
+  async readPageMetaFromFile() {
+    const content = readFileSync$1(this.path.absolutePath, "utf-8");
+    const sfc = parseSFC(content, { filename: this.path.absolutePath });
+    const meta = await tryPageMetaFromMacro(sfc);
+    if (meta) {
+      return meta;
+    }
+    return tryPageMetaFromCustomBlock(sfc, this.ctx.options.routeBlockLang);
   }
-  return true;
 }
-function readFileSync(path) {
+function parseSFC(code, options) {
   try {
-    return fs.readFileSync(path, { encoding: "utf-8" });
-  } catch {
-    return "";
+    return parse$2(code, {
+      pad: "space",
+      ...options
+    }).descriptor || parse$2({
+      source: code,
+      ...options
+    });
+  } catch (error) {
+    throw new Error(`[vite-plugin-uni-pages] Vue3's "@vue/compiler-sfc" is required. 
+Original error: 
+${error}`);
   }
 }
-function writeFileSync(path, content) {
-  fs.writeFileSync(path, content, { encoding: "utf-8" });
+async function tryPageMetaFromMacro(sfc) {
+  const sfcScript = sfc.scriptSetup || sfc.script;
+  if (!sfcScript) {
+    return void 0;
+  }
+  const ast = babelParse(sfcScript.content, sfcScript.lang || "js", {
+    plugins: [["importAttributes", { deprecatedAssertSyntax: true }]]
+  });
+  const macro = findMacro(ast.body, sfc.filename);
+  if (macro) {
+    const imports = findImports(ast.body).map((imp) => babelGenerate(imp).code);
+    const [macroOption] = macro.arguments;
+    const code = babelGenerate(macroOption).code;
+    let script = "";
+    const importScript = imports.join("");
+    script += importScript;
+    script += `export default ${code}`;
+    const result = await execScript(script, sfc.filename);
+    return result;
+  }
+  return void 0;
+}
+async function tryPageMetaFromCustomBlock(sfc, routeBlockLang) {
+  const block = getRouteSfcBlock(sfc);
+  const routeBlock = getRouteBlock(sfc.filename, block, routeBlockLang);
+  const pageMeta = {
+    type: routeBlock?.attr.type ?? "page"
+  };
+  if (routeBlock) {
+    assign(pageMeta, routeBlock.content);
+  }
+  return pageMeta;
+}
+function findMacro(stmts, filename) {
+  const nodes = stmts.map((raw) => {
+    let node = raw;
+    if (raw.type === "ExpressionStatement")
+      node = raw.expression;
+    return isCallOf(node, "definePage") ? node : void 0;
+  }).filter((node) => !!node);
+  if (!nodes.length)
+    return;
+  if (nodes.length > 1) {
+    throw new Error(`\u6BCF\u4E2A\u6587\u4EF6\u53EA\u5141\u8BB8\u8C03\u7528\u4E00\u6B21 definePage(): ${filename}`);
+  }
+  const macro = nodes[0];
+  const [opt] = macro.arguments;
+  if (opt && !t.isFunctionExpression(opt) && !t.isArrowFunctionExpression(opt) && !t.isObjectExpression(opt)) {
+    debug.definePage(`definePage() only accept argument in function or object: ${filename}`);
+    return;
+  }
+  return macro;
+}
+function findImports(stmts) {
+  return stmts.map((node) => node.type === "ImportDeclaration" ? node : void 0).filter((node) => !!node);
 }
 
 var __defProp = Object.defineProperty;
@@ -317,14 +446,15 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 let lsatPagesJson = "";
-const { setCache, hasChanged } = useCachedPages();
 class PageContext {
   constructor(userOptions, viteRoot = process.cwd()) {
     __publicField(this, "_server");
     __publicField(this, "pagesGlobConfig");
     __publicField(this, "pagesConfigSourcePaths", []);
-    __publicField(this, "pagesPath", []);
-    __publicField(this, "subPagesPath", {});
+    __publicField(this, "pages", /* @__PURE__ */ new Map());
+    // abs path -> Page
+    __publicField(this, "subPages", /* @__PURE__ */ new Map());
+    // root -> abs path -> page
     __publicField(this, "pageMetaData", []);
     __publicField(this, "subPageMetaData", []);
     __publicField(this, "resolvedPagesJSONPath", "");
@@ -367,17 +497,30 @@ class PageContext {
     const pageDirFiles = this.options.dirs.map((dir) => {
       return { dir, files: getPagePaths(dir, this.options) };
     });
-    this.pagesPath = pageDirFiles.map((page) => page.files).flat();
-    debug.pages(this.pagesPath);
+    const paths = pageDirFiles.map((page) => page.files).flat();
+    debug.pages(paths);
+    const pages = /* @__PURE__ */ new Map();
+    for (const path2 of paths) {
+      const page = this.pages.get(path2.absolutePath) || new Page(this, path2);
+      pages.set(path2.absolutePath, page);
+    }
+    this.pages = pages;
   }
   async scanSubPages() {
-    const subPagesPath = {};
+    const paths = {};
+    const subPages = /* @__PURE__ */ new Map();
     for (const dir of this.options.subPackages) {
       const pagePaths = getPagePaths(dir, this.options);
-      subPagesPath[dir] = pagePaths;
+      paths[dir] = pagePaths;
+      const pages = /* @__PURE__ */ new Map();
+      for (const path2 of pagePaths) {
+        const page = this.subPages.get(dir)?.get(path2.absolutePath) || new Page(this, path2);
+        pages.set(path2.absolutePath, page);
+      }
+      subPages.set(dir, pages);
     }
-    this.subPagesPath = subPagesPath;
-    debug.subPages(this.subPagesPath);
+    debug.subPages(JSON.stringify(paths, null, 2));
+    this.subPages = subPages;
   }
   setupViteServer(server) {
     if (this._server === server)
@@ -438,20 +581,6 @@ class PageContext {
       type: "full-reload"
     });
   }
-  async parsePage(page) {
-    const { relativePath, absolutePath } = page;
-    const routeSfcBlock = await getRouteSfcBlock(absolutePath);
-    const routeBlock = await getRouteBlock(absolutePath, routeSfcBlock, this.options);
-    setCache(absolutePath, routeSfcBlock);
-    const relativePathWithFileName = relativePath.replace(path.extname(relativePath), "");
-    const pageMetaDatum = {
-      path: normalizePath(relativePathWithFileName),
-      type: routeBlock?.attr.type ?? "page"
-    };
-    if (routeBlock)
-      assign(pageMetaDatum, routeBlock.content);
-    return pageMetaDatum;
-  }
   /**
    * parse pages rules && set page type
    * @param pages page path array
@@ -460,7 +589,11 @@ class PageContext {
    * @returns pages rules
    */
   async parsePages(pages, type, overrides) {
-    const generatedPageMetaData = await Promise.all(pages.map(async (page) => await this.parsePage(page)));
+    const jobs = [];
+    for (const [_, page] of pages) {
+      jobs.push(page.getPageMeta());
+    }
+    const generatedPageMetaData = await Promise.all(jobs);
     const customPageMetaData = overrides || [];
     const result = customPageMetaData.length ? mergePageMetaDataArray(generatedPageMetaData.concat(customPageMetaData)) : generatedPageMetaData;
     const parseMeta = result.filter(
@@ -492,14 +625,14 @@ class PageContext {
     return result;
   }
   async mergePageMetaData() {
-    const pageMetaData = await this.parsePages(this.pagesPath, "main", this.pagesGlobConfig?.pages);
+    const pageMetaData = await this.parsePages(this.pages, "main", this.pagesGlobConfig?.pages);
     this.pageMetaData = pageMetaData;
     debug.pages(this.pageMetaData);
   }
   async mergeSubPageMetaData() {
     const subPageMaps = {};
     const subPackages = this.pagesGlobConfig?.subPackages || [];
-    for (const [dir, pages] of Object.entries(this.subPagesPath)) {
+    for (const [dir, pages] of this.subPages) {
       const basePath = slash(path.join(this.options.root, this.options.outDir));
       const root = slash(path.relative(basePath, path.join(this.options.root, dir)));
       const globPackage = subPackages?.find((v) => v.root === root);
@@ -516,7 +649,18 @@ class PageContext {
   }
   async updatePagesJSON(filepath) {
     if (filepath) {
-      if (!await hasChanged(filepath)) {
+      let page = this.pages.get(filepath);
+      if (!page) {
+        let subPage;
+        for (const [_, pages2] of this.subPages) {
+          subPage = pages2.get(filepath);
+          if (subPage) {
+            break;
+          }
+        }
+        page = subPage;
+      }
+      if (page && !await page.hasChanged()) {
         debug.cache(`The route block on page ${filepath} did not send any changes, skipping`);
         return false;
       }
@@ -644,16 +788,39 @@ function VitePluginUniPages(userOptions = {}) {
     },
     // Applet do not support custom route block, so we need to remove the route block here
     async transform(code, id) {
-      if (!/\.n?vue$/.test(id) && !code.includes("</route>"))
+      if (!FILE_EXTENSIONS.find((ext) => id.endsWith(ext))) {
         return null;
+      }
+      const sfc = parseSFC(code, { filename: id });
+      let macro;
+      if (sfc.scriptSetup) {
+        const ast = babelParse(sfc.scriptSetup.content, sfc.scriptSetup.lang || "js");
+        macro = findMacro(ast.body, sfc.filename);
+      }
+      if (!macro && sfc.script) {
+        const ast = babelParse(sfc.script.content, sfc.script.lang || "js");
+        macro = findMacro(ast.body, sfc.filename);
+      }
+      const routeBlock = sfc.customBlocks.find((block) => block.type === "route");
+      if (!macro && !routeBlock)
+        return null;
+      if (macro && routeBlock)
+        throw new Error(`\u4E0D\u652F\u6301\u6DF7\u5408\u4F7F\u7528 definePage() \u548C <route/> ${id}`);
       const s = new MagicString(code);
-      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);
+      if (macro)
+        s.remove(macro.start, macro.end);
+      if (routeBlock) {
+        console.log(lightYellow("\u8B66\u544A\uFF1A"), `${bold("<route/>")} \u6807\u7B7E\u5DF2\u5E9F\u5F03\uFF0C\u5C06\u5728\u4E0B\u4E00\u4E2A\u7248\u672C\u4E2D\u79FB\u9664\uFF0C\u8BF7\u4F7F\u7528 definePage() \u4EE3\u66FF\uFF1B${link("\u67E5\u770B\u8FC1\u79FB\u6307\u5357", "https://uni-helper.js.org/vite-plugin-uni-pages/definePage")}\u3002`);
+        console.log(dim(id));
+        console.log();
+        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);
+        }
       }
       if (s.hasChanged()) {
         return {
@@ -680,4 +847,4 @@ function VitePluginUniPages(userOptions = {}) {
   };
 }
 
-export { FILE_EXTENSIONS, MODULE_ID_VIRTUAL, OUTPUT_NAME, PageContext, RESOLVED_MODULE_ID_VIRTUAL, VitePluginUniPages, checkPagesJsonFile, debug, VitePluginUniPages as default, defineUniPages, extsToGlob, getPageFiles, getRouteBlock, getRouteSfcBlock, invalidatePagesModule, isTargetFile, mergePageMetaDataArray, parseCustomBlock, parseSFC, readFileSync, resolveOptions, resolvePageDirs, useCachedPages, writeFileSync };
+export { FILE_EXTENSIONS, MODULE_ID_VIRTUAL, OUTPUT_NAME, Page, PageContext, RESOLVED_MODULE_ID_VIRTUAL, VitePluginUniPages, babelGenerate, checkPagesJsonFile, debug, VitePluginUniPages as default, defineUniPages, execScript, extsToGlob, findImports, findMacro, getPageFiles, getRouteBlock, getRouteSfcBlock, invalidatePagesModule, isTargetFile, mergePageMetaDataArray, parseCustomBlock, parseSFC, readFileSync, resolveOptions, resolvePageDirs, tryPageMetaFromCustomBlock, tryPageMetaFromMacro, writeFileSync };

package/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="./client.d.ts" />
+
+export * from './dist'
+
+export { default } from './dist'