minista 2.8.2 → 3.0.0-alpha.0

package/bin/minista.js

@@ -1,10 +1,4 @@
 #!/usr/bin/env node
 "use strict"
 
-if (typeof __dirname !== "undefined") {
-  const version = process.versions.node
-  console.error(`\nNode.js v${version} is not supported by minista
-Please upgrade to a version of Node.js with complete ESM support: "^14.15.0 || >=16.0.0"\n`)
-} else {
-  import("../dist/cli.js")
-}
+import("../dist/cli/index.js")

package/client.d.ts

@@ -1,91 +1,30 @@
-// CSS modules
-type CSSModuleClasses = { readonly [key: string]: string }
-
-declare module "*.module.css" {
-  const classes: CSSModuleClasses
-  export default classes
-}
-declare module "*.module.scss" {
-  const classes: CSSModuleClasses
-  export default classes
-}
-declare module "*.module.sass" {
-  const classes: CSSModuleClasses
-  export default classes
-}
-declare module "*.module.less" {
-  const classes: CSSModuleClasses
-  export default classes
-}
-declare module "*.module.styl" {
-  const classes: CSSModuleClasses
-  export default classes
-}
-declare module "*.module.stylus" {
-  const classes: CSSModuleClasses
-  export default classes
-}
-declare module "*.module.pcss" {
-  const classes: CSSModuleClasses
-  export default classes
-}
-
-// CSS
-declare module "*.css" {
-  const css: string
-  export default css
-}
-declare module "*.scss" {
-  const css: string
-  export default css
-}
-declare module "*.sass" {
-  const css: string
-  export default css
-}
-declare module "*.less" {
-  const css: string
-  export default css
-}
-declare module "*.styl" {
-  const css: string
-  export default css
-}
-declare module "*.stylus" {
-  const css: string
-  export default css
-}
-declare module "*.pcss" {
-  const css: string
-  export default css
-}
+/// <reference types="vite/client" />
 
+// MDX
 declare module "*.mdx" {
   import { MDXProps } from "mdx/types"
+
   export default function MDXContent(props: MDXProps): JSX.Element
 }
-
 declare module "*.md" {
-  export { default } from "*.mdx"
+  import { MDXProps } from "mdx/types"
+
+  export default function MDXContent(props: MDXProps): JSX.Element
 }
 
+// SVGR
 declare module "*.svg" {
   import * as React from "react"
 
-  const ReactComponent: React.FunctionComponent<
+  export const ReactComponent: React.FunctionComponent<
     React.SVGProps<SVGSVGElement> & { title?: string }
   >
-  export default ReactComponent
 }
 
+// Partial Hydration
 declare module "*?ph" {
   import * as React from "react"
 
-  const ReactComponent: React.FunctionComponent<React.PropsWithChildren>
-  export default ReactComponent
-}
-
-declare module "*?raw" {
-  const src: string
-  export default src
+  const ph: React.FunctionComponent<React.PropsWithChildren>
+  export default ph
 }

package/dist/cli/build.js

@@ -0,0 +1,101 @@
+import path from "node:path";
+import fs from "fs-extra";
+import pc from "picocolors";
+import {
+  defineConfig as defineViteConfig,
+  mergeConfig as mergeViteConfig,
+  build as viteBuild
+} from "vite";
+import beautify from "js-beautify";
+import { resolveConfig } from "../config/index.js";
+import { pluginSsg } from "../plugins/ssg.js";
+import { pluginBundle } from "../plugins/bundle.js";
+async function build(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig);
+  const mergedViteConfig = mergeViteConfig(
+    config.vite,
+    defineViteConfig({
+      build: { write: false },
+      plugins: [pluginSsg(config), pluginBundle()]
+    })
+  );
+  const result = await viteBuild(mergedViteConfig);
+  const items = result.output;
+  if (items.length === 0) {
+    return console.log("No content to build.");
+  }
+  const resolvedOut = path.join(config.sub.resolvedRoot, config.main.out);
+  const resolvedPublic = path.join(config.sub.resolvedRoot, config.main.public);
+  const hasPublic = await fs.pathExists(resolvedPublic);
+  await fs.emptyDir(resolvedOut);
+  hasPublic && await fs.copy(resolvedPublic, resolvedOut);
+  const bundleCssName = path.join(
+    config.main.assets.outDir,
+    config.main.assets.bundle.outName + ".css"
+  );
+  const vite3BugBundleCssName = path.join(
+    config.main.assets.outDir,
+    "bundle.css"
+  );
+  const hasBundle = items.some(
+    (item) => item.fileName === bundleCssName || item.fileName === vite3BugBundleCssName
+  );
+  await Promise.all(
+    items.map(async (item) => {
+      const isPage = item.fileName.match(/src\/pages\/.*\.html$/);
+      const isJs = item.fileName.match(/.*\.js$/);
+      const isCss = item.fileName.match(/.*\.css$/);
+      const isBundleJs = item.fileName.match(/__minista_bundle_assets\.js$/);
+      const isBundleCss = item.fileName.match(/__minista_bundle_assets\.css$/);
+      const isVite3BugBundleCss = item.fileName === vite3BugBundleCssName;
+      if (isBundleJs) {
+        return;
+      }
+      let fileName = item.fileName;
+      isPage && (fileName = item.fileName.replace(/src\/pages\//, ""));
+      isBundleCss && (fileName = bundleCssName);
+      isVite3BugBundleCss && (fileName = bundleCssName);
+      let data = "";
+      item.source && (data = item.source);
+      item.code && (data = item.code);
+      if (!data) {
+        return;
+      }
+      if (isPage && !hasBundle) {
+        data = data.replace(
+          /<link.*data-minista-build-bundle-href=.*?>/g,
+          "\n\n"
+        );
+      }
+      if (isPage) {
+        data = data.replace(/data-minista-build-bundle-href=/g, "href=").replace(/data-minista-build-css-href=/g, "href=").replace(/data-minista-build-js-src=/g, "src=");
+      }
+      if (isPage && config.main.beautify.useHtml) {
+        data = beautify.html(data, config.main.beautify.htmlOptions);
+      }
+      if (isJs && config.main.beautify.useAssets) {
+        data = beautify.js(data, config.main.beautify.jsOptions);
+      }
+      if (isCss && config.main.beautify.useAssets) {
+        data = beautify.css(data, config.main.beautify.cssOptions);
+      }
+      const routePath = path.join(
+        config.sub.resolvedRoot,
+        config.main.out,
+        fileName
+      );
+      const relativePath = path.relative(process.cwd(), routePath);
+      const dataSize = (data.length / 1024).toFixed(2);
+      return await fs.outputFile(routePath, data).then(() => {
+        console.log(
+          `${pc.bold(pc.green("BUILD"))} ${pc.bold(relativePath)} ` + pc.gray(`${dataSize} KiB`)
+        );
+      }).catch((err) => {
+        console.error(err);
+      });
+    })
+  );
+}
+export {
+  build
+};

package/dist/cli/develop.js

@@ -0,0 +1,20 @@
+import {
+  createServer as createViteServer,
+  defineConfig as defineViteConfig,
+  mergeConfig as mergeViteConfig
+} from "vite";
+import { resolveConfig } from "../config/index.js";
+import { pluginServe } from "../plugins/serve.js";
+async function develop(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig);
+  const mergedViteConfig = mergeViteConfig(
+    config.vite,
+    defineViteConfig({ plugins: [pluginServe(config)] })
+  );
+  const viteServer = await createViteServer(mergedViteConfig);
+  await viteServer.listen();
+  viteServer.printUrls();
+}
+export {
+  develop
+};

package/dist/cli/index.js

@@ -0,0 +1,74 @@
+import fs from "fs-extra";
+import { cac } from "cac";
+const cli = cac("minista");
+function pkgVersion() {
+  const pkgURL = new URL("../../package.json", import.meta.url);
+  const pkg = JSON.parse(fs.readFileSync(pkgURL, "utf8"));
+  return pkg.version;
+}
+cli.option("-c, --config <file>", `[string] use specified config file`).option("--base <path>", `[string] public base path (default: /)`);
+cli.command("[root]", "start dev server").alias("develop").alias("dev").alias("serve").option("--host [host]", "[string] specify hostname").option("--port <port>", "[number] specify port").option("--strictPort", "[boolean] exit if specified port is already in use").option("--https", "[boolean] use TLS + HTTP/2").option("--open [path]", "[boolean | string] open browser on startup").option("--cors", "[boolean] enable CORS").action(
+  async (root, options) => {
+    try {
+      const { develop } = await import("./develop.js");
+      await develop({
+        configFile: options.config,
+        root,
+        base: options.base,
+        vite: {
+          server: {
+            host: options.host,
+            port: options.port,
+            strictPort: options.strictPort,
+            https: options.https,
+            open: options.open,
+            cors: options.cors
+          }
+        }
+      });
+    } catch (err) {
+      console.log(err);
+      process.exit(1);
+    }
+  }
+);
+cli.command("build [root]", "build for production").action(async (root, options) => {
+  try {
+    const { build } = await import("./build.js");
+    await build({
+      configFile: options.config,
+      root,
+      base: options.base
+    });
+  } catch (err) {
+    console.log(err);
+    process.exit(1);
+  }
+});
+cli.command("preview [root]", "locally preview production build").option("--host [host]", "[string] specify hostname").option("--port <port>", "[number] specify port").option("--strictPort", "[boolean] exit if specified port is already in use").option("--https", "[boolean] use TLS + HTTP/2").option("--open [path]", "[boolean | string] open browser on startup").action(
+  async (root, options) => {
+    try {
+      const { preview } = await import("./preview.js");
+      await preview({
+        configFile: options.config,
+        root,
+        base: options.base,
+        vite: {
+          server: {
+            host: options.host,
+            port: options.port,
+            strictPort: options.strictPort,
+            https: options.https,
+            open: options.open
+          }
+        }
+      });
+    } catch (err) {
+      console.log(err);
+      process.exit(1);
+    }
+  }
+);
+cli.help();
+cli.version(pkgVersion());
+cli.parse();

package/dist/cli/preview.js

@@ -0,0 +1,10 @@
+import { preview as vitePreview } from "vite";
+import { resolveConfig } from "../config/index.js";
+async function preview(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig);
+  const viteServer = await vitePreview(config.vite);
+  viteServer.printUrls();
+}
+export {
+  preview
+};

package/dist/compile/app.js

@@ -0,0 +1,107 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import ReactDOMServer from "react-dom/server";
+import { StaticRouter } from "react-router-dom/server.js";
+import { HelmetProvider } from "react-helmet-async";
+import { Route, Routes } from "react-router-dom";
+function App({
+  resolvedGlobal,
+  resolvedPages
+}) {
+  const global = resolvedGlobal;
+  const routes = resolvedPages;
+  return /* @__PURE__ */ jsx(Fragment, {
+    children: /* @__PURE__ */ jsx(Routes, {
+      children: routes.map((page) => {
+        const location = { pathname: page.path };
+        if (global.component) {
+          const GlobalComponent = global.component;
+          const PageComponent = page.component;
+          return /* @__PURE__ */ jsx(Route, {
+            path: page.path,
+            element: /* @__PURE__ */ jsx(GlobalComponent, {
+              ...global.staticData.props,
+              ...page.staticData.props,
+              frontmatter: page.frontmatter,
+              location,
+              children: /* @__PURE__ */ jsx(PageComponent, {
+                ...global.staticData.props,
+                ...page.staticData.props,
+                frontmatter: page.frontmatter,
+                location
+              })
+            })
+          }, page.path);
+        } else {
+          const PageComponent = page.component;
+          return /* @__PURE__ */ jsx(Route, {
+            path: page.path,
+            element: /* @__PURE__ */ jsx(PageComponent, {
+              ...global.staticData.props,
+              ...page.staticData.props,
+              frontmatter: page.frontmatter,
+              location
+            })
+          }, page.path);
+        }
+      })
+    })
+  });
+}
+function compileApp({
+  url,
+  resolvedGlobal,
+  resolvedPages,
+  headTags,
+  startTags,
+  endTags
+}) {
+  const helmetContext = {};
+  const markup = ReactDOMServer.renderToString(
+    /* @__PURE__ */ jsx(StaticRouter, {
+      location: url,
+      children: /* @__PURE__ */ jsx(HelmetProvider, {
+        context: helmetContext,
+        children: /* @__PURE__ */ jsx(App, {
+          resolvedGlobal,
+          resolvedPages
+        })
+      })
+    })
+  );
+  const { helmet } = helmetContext;
+  const staticHelmet = (data) => {
+    return data.replace(/data-rh="true"/g, "");
+  };
+  const htmlAttributes = Object.hasOwn(
+    helmet.htmlAttributes.toComponent(),
+    "lang"
+  ) ? helmet.htmlAttributes.toString() : `lang="ja" ${helmet.htmlAttributes.toString()}`;
+  const insertHeadTags = headTags ? headTags : "";
+  const insertStartTags = startTags ? `${startTags}
+` : "";
+  const insertEndTags = endTags ? `
+${endTags}` : "";
+  const html = `
+  <!doctype html>
+  <html ${htmlAttributes}>
+    <head>
+      <meta charset="UTF-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+      ${staticHelmet(helmet.title.toString())}
+      ${staticHelmet(helmet.meta.toString())}
+      ${insertHeadTags}
+      ${staticHelmet(helmet.link.toString())}
+      ${staticHelmet(helmet.style.toString())}
+      ${staticHelmet(helmet.script.toString())}
+    </head>
+    <body ${helmet.bodyAttributes.toString()}>
+      ${insertStartTags}${markup}${insertEndTags}
+    </body>
+  </html>
+`;
+  return html;
+}
+export {
+  App,
+  compileApp
+};

package/dist/compile/comment.js

@@ -0,0 +1,20 @@
+import { parse as parseHtml } from "node-html-parser";
+function compileComment(html) {
+  let parsedHtml = parseHtml(html);
+  const targets = parsedHtml.querySelectorAll(
+    `[data-minista-compile-target="comment"]`
+  );
+  targets.map((target) => {
+    const parent = target.parentNode;
+    const text = target.innerText;
+    const space = text.includes("\n") ? "\n" : " ";
+    const content = "<!--" + space + text + space + "-->";
+    const parsedContent = parseHtml(content, { comment: true });
+    return parent.exchangeChild(target, parsedContent);
+  });
+  const htmlStr = parsedHtml.toString();
+  return htmlStr;
+}
+export {
+  compileComment
+};

package/dist/compile/fetch.js

@@ -0,0 +1,34 @@
+import { transformWithEsbuild } from "vite";
+async function compileFetch(getStaticData) {
+  let fncStr = "" + getStaticData;
+  const transformedFnc = await transformWithEsbuild(fncStr, "", {
+    format: "esm",
+    platform: "node",
+    loader: "ts"
+  });
+  fncStr = transformedFnc.code;
+  fncStr = `const { fetch } = await import("undici")
+  ${fncStr}
+  return await getStaticData()`;
+  const AsyncFunction = Object.getPrototypeOf(async function() {
+  }).constructor;
+  const compiledFetch = new AsyncFunction("", fncStr);
+  return compiledFetch;
+}
+async function compileGlobalFetch(getStaticData) {
+  const compiledFetch = await compileFetch(
+    getStaticData
+  );
+  return compiledFetch;
+}
+async function compilePageFetch(getStaticData) {
+  const compiledFetch = await compileFetch(
+    getStaticData
+  );
+  return compiledFetch;
+}
+export {
+  compileFetch,
+  compileGlobalFetch,
+  compilePageFetch
+};

package/dist/compile/markdown.js

@@ -0,0 +1,38 @@
+import { parse as parseHtml } from "node-html-parser";
+import { compile as compileMdx, run as runMdx } from "@mdx-js/mdx";
+import { createElement } from "react";
+import ReactDOMServer from "react-dom/server";
+async function compileMarkdown(html, config) {
+  let parsedHtml = parseHtml(html);
+  const targets = parsedHtml.querySelectorAll(
+    `[data-minista-compile-target="markdown"]`
+  );
+  await Promise.all(
+    targets.map(async (target) => {
+      const parent = target.parentNode;
+      const childs = target.childNodes;
+      const childsStr = childs.toString();
+      const content = await compileMdx(childsStr, config);
+      let contentStr = content.value.toString();
+      contentStr = contentStr.replace(
+        /import {(.+?)} from "react\/jsx-runtime"/,
+        'const {$1} = await import("react/jsx-runtime")'
+      );
+      contentStr = contentStr.replace(/\sas[(^const.*await import.*?)]/g, ": ");
+      contentStr = contentStr.replace(
+        /export default MDXContent/g,
+        "return MDXContent"
+      );
+      contentStr = contentStr.replace(/\nexport.*;/g, "\n");
+      const contentReact = createElement(await runMdx(contentStr, {}));
+      const contentHtml = ReactDOMServer.renderToString(contentReact);
+      const parsedContent = parseHtml(contentHtml);
+      return parent.exchangeChild(target, parsedContent);
+    })
+  );
+  const htmlStr = parsedHtml.toString();
+  return htmlStr;
+}
+export {
+  compileMarkdown
+};

package/dist/compile/tags.js

@@ -0,0 +1,164 @@
+import path from "node:path";
+import picomatch from "picomatch";
+import { getHtmlPath } from "../utility/path.js";
+function compileBundleTag({
+  pathname,
+  config
+}) {
+  let assetPath = "";
+  const assetName = path.join(
+    config.main.assets.outDir,
+    config.main.assets.bundle.outName + ".css"
+  );
+  if (config.main.base === "" || config.main.base === "./") {
+    const fileName = getHtmlPath(pathname);
+    const filePath = path.dirname(fileName);
+    const bundleCssPath = path.join("./", assetName);
+    const relativePath = path.relative(filePath, bundleCssPath);
+    assetPath = relativePath;
+  } else {
+    assetPath = path.join(config.main.base, assetName);
+  }
+  return `<link rel="stylesheet" data-minista-build-bundle-href="${assetPath}">`;
+}
+function compileLinkTag({
+  mode,
+  pathname,
+  entry,
+  config
+}) {
+  let assetPath = "";
+  const assetName = path.join(config.main.assets.outDir, entry.name + ".css");
+  if (mode === "serve") {
+    assetPath = path.join("/", "@minista-project-root", entry.input);
+    return `<link rel="stylesheet" href="${assetPath}">`;
+  }
+  if (config.main.base === "" || config.main.base === "./") {
+    const fileName = getHtmlPath(pathname);
+    const filePath = path.dirname(fileName);
+    const cssPath = path.join("./", assetName);
+    const relativePath = path.relative(filePath, cssPath);
+    assetPath = relativePath;
+  } else {
+    assetPath = path.join(config.main.base, assetName);
+  }
+  return `<link rel="stylesheet" data-minista-build-css-href="${assetPath}">`;
+}
+function compileScriptTag({
+  mode,
+  pathname,
+  entry,
+  config
+}) {
+  let assetPath = "";
+  const assetName = path.join(config.main.assets.outDir, entry.name + ".js");
+  const deferStr = entry.loadType === "defer" ? " defer" : "";
+  const asyncStr = entry.loadType === "async" ? " async" : "";
+  if (mode === "serve") {
+    assetPath = path.join("/", "@minista-project-root", entry.input);
+    return `<script${deferStr}${asyncStr} src="${assetPath}"><\/script>`;
+  }
+  if (config.main.base === "" || config.main.base === "./") {
+    const fileName = getHtmlPath(pathname);
+    const filePath = path.dirname(fileName);
+    const cssPath = path.join("./", assetName);
+    const relativePath = path.relative(filePath, cssPath);
+    assetPath = relativePath;
+  } else {
+    assetPath = path.join(config.main.base, assetName);
+  }
+  return `<script${deferStr}${asyncStr} data-minista-build-js-src="${assetPath}"><\/script>`;
+}
+function compileEntryTags({
+  mode,
+  pathname,
+  config
+}) {
+  function scriptFilter(entries, isScript) {
+    const regex = /\.(js|cjs|mjs|jsx|ts|tsx)$/;
+    if (isScript) {
+      return entries.filter((entry) => entry.input.match(regex));
+    } else {
+      return entries.filter((entry) => !entry.input.match(regex));
+    }
+  }
+  function createTags(entries) {
+    let linkTags = [];
+    let scriptTags = [];
+    const linkEntries = scriptFilter(entries, false);
+    const scriptEntries = scriptFilter(entries, true);
+    if (linkEntries.length > 0) {
+      linkTags = linkEntries.map((entry) => {
+        return compileLinkTag({
+          mode,
+          pathname,
+          entry,
+          config
+        });
+      });
+    }
+    if (scriptEntries.length > 0) {
+      scriptTags = scriptEntries.map((entry) => {
+        return compileScriptTag({
+          mode,
+          pathname,
+          entry,
+          config
+        });
+      });
+    }
+    return { linkTags, scriptTags };
+  }
+  let headTags = "";
+  let startTags = "";
+  let endTags = "";
+  let headLinkTags = [];
+  let headScriptTags = [];
+  let startLinkTags = [];
+  let startScriptTags = [];
+  let endLinkTags = [];
+  let endScriptTags = [];
+  let bundleCssTag = "";
+  let bundleJsTag = "";
+  if (mode === "ssg") {
+    bundleCssTag = compileBundleTag({ pathname, config });
+  }
+  if (mode === "serve") {
+    bundleJsTag = `<script type="module">import "/@minista/dist/server/bundle.js"<\/script>`;
+  }
+  const pageEntries = config.sub.resolvedEntry.filter((entry) => {
+    return picomatch.isMatch(pathname, entry.insertPages);
+  });
+  const headEntries = pageEntries.filter((entry) => entry.position === "head");
+  const startEntries = pageEntries.filter((entry) => entry.position === "start");
+  const endEntries = pageEntries.filter((entry) => entry.position === "end");
+  if (headEntries.length > 0) {
+    const { linkTags, scriptTags } = createTags(headEntries);
+    headLinkTags = linkTags;
+    headScriptTags = scriptTags;
+  }
+  if (startEntries.length > 0) {
+    const { linkTags, scriptTags } = createTags(startEntries);
+    startLinkTags = linkTags;
+    startScriptTags = scriptTags;
+  }
+  if (endEntries.length > 0 || mode === "serve") {
+    const { linkTags, scriptTags } = createTags(endEntries);
+    endLinkTags = linkTags;
+    endScriptTags = scriptTags;
+  }
+  headTags = [...headLinkTags, bundleCssTag, ...headScriptTags].filter((tag) => tag).join("\n");
+  startTags = [...startLinkTags, ...startScriptTags].filter((tag) => tag).join("\n");
+  endTags = [...endLinkTags, ...endScriptTags, bundleJsTag].filter((tag) => tag).join("\n");
+  return {
+    headTags,
+    startTags,
+    endTags
+  };
+}
+export {
+  compileBundleTag,
+  compileEntryTags,
+  compileLinkTag,
+  compileScriptTag
+};