weapp-vite 0.0.2-alpha.1 → 0.0.2-alpha.3

package/dist/chunk-6FYX6NKW.js

@@ -0,0 +1,442 @@
+// src/build.ts
+import process2 from "node:process";
+import { build } from "vite";
+import { addExtension as addExtension3, defu as defu2, removeExtension as removeExtension3 } from "@weapp-core/shared";
+
+// src/plugins/index.ts
+import path4 from "node:path";
+import fs3 from "fs-extra";
+import MagicString from "magic-string";
+import { addExtension as addExtension2, removeExtension as removeExtension2 } from "@weapp-core/shared";
+import fg from "fast-glob";
+import { isCSSRequest, preprocessCSS } from "vite";
+
+// src/utils/scan.ts
+import path from "pathe";
+import fs from "fs-extra";
+import klaw from "klaw";
+import { addExtension, isObject, removeExtension } from "@weapp-core/shared";
+var defaultExcluded = ["**/node_modules/**", "**/miniprogram_npm/**"];
+function searchAppEntry(root, formatPath) {
+  const extensions = ["js", "ts"];
+  const appJsonPath = path.resolve(root, "app.json");
+  if (fs.existsSync(appJsonPath)) {
+    for (const ext of extensions) {
+      const entryPath = path.resolve(root, addExtension("app", `.${ext}`));
+      if (fs.existsSync(entryPath)) {
+        const appJson = fs.readJSONSync(appJsonPath, { throws: false });
+        const deps = [];
+        if (appJson) {
+          if (Array.isArray(appJson.pages)) {
+            deps.push(...appJson.pages.map((x) => {
+              return {
+                path: x,
+                type: "page"
+              };
+            }));
+          }
+          if (isObject(appJson.usingComponents)) {
+            deps.push(...parseJsonUseComponents(appJson));
+          }
+          if (Array.isArray(appJson.subpackages)) {
+            for (const subpackage of appJson.subpackages) {
+              deps.push(...subpackage.map((x) => {
+                return {
+                  type: "subpackage",
+                  ...x
+                };
+              }));
+            }
+          }
+        }
+        return {
+          path: formatPath ? formatPath(entryPath) : entryPath,
+          deps,
+          type: "app"
+        };
+      }
+    }
+  }
+}
+function searchPageEntry(wxmlPath) {
+  if (fs.existsSync(wxmlPath)) {
+    const extensions = ["js", "ts"];
+    const base = removeExtension(wxmlPath);
+    for (const ext of extensions) {
+      const entryPath = addExtension(base, `.${ext}`);
+      if (fs.existsSync(entryPath)) {
+        return entryPath;
+      }
+    }
+  }
+}
+function parseJsonUseComponents(json) {
+  const deps = [];
+  if (isObject(json.usingComponents)) {
+    deps.push(...Object.values(json.usingComponents).map((x) => {
+      return {
+        path: x,
+        type: "component"
+      };
+    }));
+  }
+  return deps;
+}
+function getWxmlEntry(wxmlPath, formatPath) {
+  const pageEntry = searchPageEntry(wxmlPath);
+  if (pageEntry) {
+    const jsonPath = addExtension(removeExtension(wxmlPath), ".json");
+    const finalPath = formatPath(pageEntry);
+    if (fs.existsSync(jsonPath)) {
+      const json = fs.readJsonSync(jsonPath, { throws: false });
+      if (json && json.component) {
+        return {
+          deps: parseJsonUseComponents(json),
+          path: finalPath,
+          type: "component"
+        };
+      } else {
+        return {
+          deps: parseJsonUseComponents(json),
+          path: finalPath,
+          type: "page"
+        };
+      }
+    }
+    return {
+      deps: [],
+      path: finalPath,
+      type: "page"
+    };
+  }
+}
+async function scanEntries(root, options) {
+  function formatPath(to) {
+    if (options?.relative) {
+      return path.relative(root, to);
+    }
+    return path.normalize(to);
+  }
+  const appEntry = searchAppEntry(root, formatPath);
+  if (appEntry) {
+    const pageEntries = [];
+    const componentEntries = [];
+    for await (const file of klaw(
+      root,
+      {
+        filter: options?.filter
+      }
+    )) {
+      if (file.stats.isFile()) {
+        if (/\.wxml$/.test(file.path)) {
+          const entry = getWxmlEntry(file.path, formatPath);
+          if (entry) {
+            if (entry.type === "component") {
+              componentEntries.push(entry);
+            } else if (entry.type === "page") {
+              pageEntries.push(entry);
+            }
+          }
+        }
+      }
+    }
+    return {
+      app: appEntry,
+      pages: pageEntries,
+      components: componentEntries,
+      subpackages: []
+      // walkPathsSet,
+    };
+  }
+}
+
+// src/utils/projectConfig.ts
+import path2 from "pathe";
+import fs2 from "fs-extra";
+
+// src/utils/index.ts
+var supportedCssLangs = ["wxss", "scss", "less", "sass", "styl"];
+var supportedCssExtensions = supportedCssLangs.map((x) => `.${x}`);
+
+// src/entry.ts
+import process from "node:process";
+import mm from "micromatch";
+import { defu } from "@weapp-core/shared";
+import path3 from "pathe";
+function createFilter(include, exclude, options) {
+  const opts = defu(options, {
+    ignore: exclude
+    // dot: true,
+    // contains: true,
+  });
+  return function(id) {
+    if (typeof id !== "string") {
+      return false;
+    }
+    if (/\0/.test(id)) {
+      return false;
+    }
+    return mm.isMatch(id, include, opts);
+  };
+}
+function getEntries(options) {
+  const { root = process.cwd(), outDir = "dist", relative, srcRoot = "" } = options;
+  const filter = createFilter(
+    [path3.join(srcRoot, "**/*")],
+    [...defaultExcluded, path3.join(root, `${outDir}/**`)],
+    { cwd: root }
+  );
+  return scanEntries(root, { filter, relative });
+}
+
+// src/cache.ts
+function createPluginCache(cache) {
+  return {
+    delete(id) {
+      return delete cache[id];
+    },
+    get(id) {
+      const item = cache[id];
+      if (!item) {
+        return;
+      }
+      item[0] = 0;
+      return item[1];
+    },
+    has(id) {
+      const item = cache[id];
+      if (!item) {
+        return false;
+      }
+      item[0] = 0;
+      return true;
+    },
+    set(id, value) {
+      cache[id] = [0, value];
+    }
+  };
+}
+
+// src/debugger.ts
+import createDebug from "debug";
+function createDebugger(namespace) {
+  const debug2 = createDebug(namespace);
+  if (debug2.enabled) {
+    return debug2;
+  }
+}
+
+// src/plugins/parse.ts
+function parseRequest(id) {
+  const [filename, rawQuery] = id.split(`?`, 2);
+  const query = Object.fromEntries(new URLSearchParams(rawQuery));
+  if (Reflect.has(query, "wxss")) {
+    query.wxss = true;
+  }
+  return {
+    filename,
+    query
+  };
+}
+
+// src/plugins/index.ts
+var debug = createDebugger("weapp-vite:plugin");
+function normalizeCssPath(id) {
+  return addExtension2(removeExtension2(id), ".wxss");
+}
+function getRealPath(res) {
+  if (res.query.wxss) {
+    return addExtension2(removeExtension2(res.filename), ".wxss");
+  }
+  return res.filename;
+}
+function vitePluginWeapp() {
+  function getInputOption(entries) {
+    return entries.reduce((acc, cur) => {
+      acc[relative(cur)] = cur;
+      return acc;
+    }, {});
+  }
+  const stylesIds = /* @__PURE__ */ new Set();
+  let configResolved;
+  let entriesSet = /* @__PURE__ */ new Set();
+  function relative(p) {
+    return path4.relative(configResolved.root, p);
+  }
+  const cacheInstance = createPluginCache(/* @__PURE__ */ Object.create(null));
+  return [
+    {
+      name: "weapp-vite:pre",
+      enforce: "pre",
+      // config->configResolved->|watching|options->buildStart
+      config(config, env) {
+        debug?.(config, env);
+      },
+      async options(options) {
+        const entries = await getEntries({
+          root: configResolved.root,
+          outDir: configResolved.build.outDir,
+          srcRoot: configResolved.weapp?.srcRoot
+        });
+        if (entries) {
+          const paths = [entries.app, ...entries.pages, ...entries.components].map((x) => {
+            return x.path;
+          });
+          const input = getInputOption(paths);
+          entriesSet = new Set(paths);
+          options.input = input;
+        }
+      },
+      configResolved(config) {
+        debug?.(config);
+        configResolved = config;
+      },
+      resolveId(source) {
+        if (/\.wxss$/.test(source)) {
+          return source.replace(/\.wxss$/, ".css?wxss");
+        }
+      },
+      load(id) {
+        if (entriesSet.has(id)) {
+          const base = removeExtension2(id);
+          const ms = new MagicString(fs3.readFileSync(id, "utf8"));
+          for (const ext of supportedCssExtensions) {
+            const mayBeCssPath = addExtension2(base, ext);
+            if (fs3.existsSync(mayBeCssPath)) {
+              this.addWatchFile(mayBeCssPath);
+              ms.prepend(`import '${mayBeCssPath}'
+`);
+            }
+          }
+          this.addWatchFile(id);
+          return {
+            code: ms.toString()
+          };
+        } else if (isCSSRequest(id)) {
+          stylesIds.add(id);
+          return {
+            code: ""
+          };
+        }
+      },
+      async buildEnd() {
+        const styles = {};
+        for (const stylesId of stylesIds) {
+          const parsed = parseRequest(stylesId);
+          const css = await fs3.readFile(getRealPath(parsed), "utf8");
+          const res = await preprocessCSS(css, stylesId, configResolved);
+          const fileName = relative(normalizeCssPath(stylesId));
+          if (styles[fileName]) {
+            styles[fileName] += res.code;
+          } else {
+            styles[fileName] = res.code;
+          }
+        }
+        for (const style of Object.entries(styles)) {
+          this.emitFile({
+            type: "asset",
+            fileName: style[0],
+            source: style[1]
+          });
+        }
+        const files = await fg(
+          // 假如去 join root 就是返回 absolute
+          ["**/*.{wxml,json,wxs,png,jpg,jpeg,gif,svg,webp}"],
+          {
+            cwd: configResolved.root,
+            ignore: [
+              ...defaultExcluded,
+              `${configResolved.build.outDir}/**`,
+              "project.config.json",
+              "project.private.config.json",
+              "package.json"
+            ],
+            absolute: false
+          }
+        );
+        for (const file of files) {
+          const filepath = path4.resolve(configResolved.root, file);
+          this.addWatchFile(filepath);
+          this.emitFile({
+            type: "asset",
+            fileName: file,
+            source: await fs3.readFile(filepath, "utf8")
+          });
+        }
+      }
+      // generateBundle(_options, _bundle) {
+      //   const files = this.getWatchFiles()
+      //   console.log(files)
+      // },
+    },
+    {
+      name: "weapp-vite"
+    },
+    {
+      name: "weapp-vite:post",
+      enforce: "post"
+    }
+  ];
+}
+
+// src/build.ts
+function getDefaultConfig() {
+  return {
+    build: {
+      rollupOptions: {
+        output: {
+          format: "cjs",
+          entryFileNames: (chunkInfo) => {
+            if (chunkInfo.name.endsWith(".ts")) {
+              return addExtension3(removeExtension3(chunkInfo.name), ".js");
+            }
+            return chunkInfo.name;
+          }
+        }
+      },
+      assetsDir: ".",
+      commonjsOptions: {
+        transformMixedEsModules: true,
+        include: void 0
+      }
+    },
+    plugins: [
+      vitePluginWeapp()
+    ]
+  };
+}
+async function runDev(options) {
+  process2.env.NODE_ENV = "development";
+  const watcher = await build(
+    defu2(
+      options,
+      getDefaultConfig(),
+      {
+        mode: "development",
+        build: {
+          watch: {},
+          minify: false
+        }
+      }
+    )
+  );
+  return watcher;
+}
+async function runProd(options) {
+  const output = await build(
+    defu2(
+      options,
+      getDefaultConfig(),
+      {
+        mode: "production"
+      }
+    )
+  );
+  return output;
+}
+
+export {
+  getDefaultConfig,
+  runDev,
+  runProd
+};