@into-mini/sfc-split-plugin 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eric
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/helper/empty.json

@@ -0,0 +1 @@
+{}

package/helper/hooks.mjs

@@ -0,0 +1,48 @@
+import { toJSONString } from '@into-mini/sfc-transformer/utils.mjs';
+
+import { readConfig } from './read.mjs';
+
+export function createEmitFile({ PLUGIN_NAME, compilation, RawSource }) {
+  return (name, content) => {
+    compilation.hooks.processAssets.tap(
+      {
+        name: PLUGIN_NAME,
+        stage: compilation.constructor.PROCESS_ASSETS_STAGE_ADDITIONAL,
+      },
+      () => {
+        compilation.emitAsset(
+          name,
+          new RawSource(
+            typeof content === 'string' ? content : toJSONString(content),
+          ),
+        );
+      },
+    );
+  };
+}
+
+export function readAndTrack(compiler, compilation) {
+  return (name) => {
+    const { filePath, config = {} } = readConfig(compiler.context, name);
+
+    if (filePath) {
+      compilation.fileDependencies.add(filePath);
+    }
+
+    return {
+      name: `${name}.json`,
+      content: config,
+      empty: Object.keys(config).length === 0,
+    };
+  };
+}
+
+export function createAddEntry(compiler) {
+  return (name, path) => {
+    new compiler.webpack.EntryPlugin(compiler.context, path, {
+      import: [path],
+      name,
+      // layer: 'base',
+    }).apply(compiler);
+  };
+}

package/helper/index.mjs

@@ -0,0 +1,62 @@
+export const COMPONENT_ROOT = 'as-components';
+
+function unique(...arr) {
+  return [...new Set(arr)];
+}
+
+export function getAllPages(config) {
+  const { entryPagePath, pages, subPackages, tabBar } = config ?? {};
+
+  const { custom = false, list = [] } = tabBar ?? {};
+
+  return unique(
+    entryPagePath,
+    ...(pages ?? []),
+    ...list.map(({ pagePath }) => pagePath),
+    ...(subPackages ?? []).flatMap(
+      (subPackage) =>
+        (subPackage.pages || []).map((page) => `${subPackage.root}/${page}`) ||
+        [],
+    ),
+    custom === true ? 'custom-tab-bar/index' : '',
+  ).filter(Boolean);
+}
+
+export function patchConfig(json) {
+  const object = structuredClone(json ?? {});
+
+  object.pages ??= [];
+
+  if (object.tabBar?.list?.length > 0) {
+    for (const tab of object.tabBar.list) {
+      if (tab.pagePath && !object.pages.includes(tab.pagePath)) {
+        object.pages.push(tab.pagePath);
+      }
+    }
+  }
+
+  object.subPackages ??= [];
+  object.preloadRule ??= {};
+
+  for (const page of object.pages) {
+    object.preloadRule[page] ??= {};
+
+    object.preloadRule[page].network = 'all';
+    object.preloadRule[page].packages ??= [];
+
+    if (!object.preloadRule[page].packages.includes(COMPONENT_ROOT)) {
+      object.preloadRule[page].packages.push(COMPONENT_ROOT);
+    }
+  }
+
+  if (
+    !object.subPackages.some((subPackage) => subPackage.root === COMPONENT_ROOT)
+  ) {
+    object.subPackages.push({
+      root: COMPONENT_ROOT,
+      pages: ['fake'],
+    });
+  }
+
+  return object;
+}

package/helper/read.mjs

@@ -0,0 +1,37 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { parse as yamlParse } from 'yaml';
+
+function tryReadFileWithParsers(base, name, ext, parser) {
+  const filePath = resolve(base, `${name}${ext}`);
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+
+    return {
+      filePath,
+      config: (parser ? parser(content) : content) || {},
+    };
+  } catch {
+    return false;
+  }
+}
+
+const candidates = [
+  { ext: '.yaml', parser: yamlParse },
+  { ext: '.yml', parser: yamlParse },
+  { ext: '.json', parser: JSON.parse },
+];
+
+export function readConfig(base, name) {
+  for (const { ext, parser } of candidates) {
+    const result = tryReadFileWithParsers(base, name, ext, parser);
+
+    if (result !== false) {
+      return result;
+    }
+  }
+
+  return false;
+}

package/helper/utils.mjs

@@ -0,0 +1,6 @@
+export const configKeys = {
+  app: 'app-json',
+  projectPrivate: 'project.private.config',
+  project: 'project.config',
+  hack: 'hack.entry',
+};

package/loader/fake-vue-loader.mjs

@@ -0,0 +1,140 @@
+import { createHash } from 'node:crypto';
+import { join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { toJSONString } from '@into-mini/sfc-transformer/utils.mjs';
+import slash from 'slash';
+
+function createShortHash(input) {
+  return createHash('sha256').update(input).digest('hex').slice(0, 8);
+}
+
+function reach(path) {
+  return fileURLToPath(import.meta.resolve(path));
+}
+
+function handleImport({
+  toThis,
+  addSmartEntry,
+  componentRoot,
+  context,
+  rootContext,
+  maps,
+  callback,
+}) {
+  if (Object.keys(maps).length > 0) {
+    for (const [name, path] of Object.entries(maps)) {
+      if (path.endsWith('.vue') && !path.startsWith('plugin://')) {
+        try {
+          const absolutePath = slash(
+            path.startsWith('.') ? resolve(context, path) : reach(path),
+          );
+          const relativePath = slash(relative(rootContext, absolutePath));
+          const hack = relativePath.startsWith('..');
+          const entryName = hack
+            ? [
+                componentRoot,
+                absolutePath
+                  .split('/')
+                  .slice(-2)
+                  .join('/')
+                  .replace(/\.vue$/, ''),
+                createShortHash(slash(relativePath)),
+              ].join('/')
+            : relativePath.replace(/\.vue$/, '');
+          const placer = toThis(entryName);
+          callback({
+            name,
+            placer,
+          });
+
+          const entryPath = relativePath.startsWith('..')
+            ? absolutePath
+            : `./${relativePath}`;
+
+          this.addDependency(resolve(absolutePath));
+          this.addMissingDependency(resolve(absolutePath));
+          addSmartEntry({
+            name: entryName,
+            path: entryPath,
+          });
+        } catch (error) {
+          console.error(error);
+        }
+      }
+    }
+  }
+}
+
+export default function loader(source, map, meta) {
+  this.cacheable();
+  const callback = this.async();
+  const { componentRoot } = this.getOptions();
+  const { entryName: thisEntryName } = this;
+  const resourcePath = slash(this.resourcePath);
+  const { paths, config, script } = this.processSfcFile({
+    source,
+    resourcePath,
+  });
+  const { rootContext, context } = this;
+
+  for (const path of paths) {
+    const filePath = join(rootContext, path);
+    this.addDependency(filePath);
+    this.addMissingDependency(filePath);
+  }
+
+  function toThis(entryName) {
+    return slash(relative(`/${thisEntryName}/..`, `/${entryName}`));
+  }
+
+  const addSmartEntry = (io) => {
+    this.addSmartEntry(io);
+  };
+
+  if (config?.usingComponents) {
+    handleImport.bind(this)({
+      toThis,
+      addSmartEntry,
+      componentRoot,
+      context,
+      rootContext,
+      maps: config.usingComponents,
+      callback({ name, placer }) {
+        config.usingComponents[name] = placer;
+
+        if (placer.includes(componentRoot)) {
+          config.componentPlaceholder ??= {};
+          config.componentPlaceholder[name] = 'view';
+        }
+      },
+    });
+  }
+
+  if (config?.componentGenerics) {
+    handleImport.bind(this)({
+      toThis,
+      addSmartEntry,
+      componentRoot,
+      context,
+      rootContext,
+      maps: Object.fromEntries(
+        Object.entries(config.componentGenerics)
+          .filter(([_, item]) => item?.default)
+          .map(([key, item]) => [key, item.default]),
+      ),
+      callback({ name, placer }) {
+        config.componentGenerics[name].default = placer;
+      },
+    });
+  }
+
+  const file = [
+    ...paths
+      .map((path) => relative(`${resourcePath}/..`, path))
+      .map((path) => `import "./${path}";`),
+    script,
+  ].join('\n');
+  this.emitFile(`${thisEntryName}.json`, toJSONString(config));
+  callback(null, file, map, meta);
+}

package/loader/hack-entry-loader.mjs

@@ -0,0 +1,5 @@
+export default function loader() {
+  console.log(this._compiler.__entries__);
+
+  return '';
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@into-mini/sfc-split-plugin",
+  "version": "0.0.0",
+  "license": "MIT",
+  "keywords": [
+    "loader",
+    "mini-program",
+    "miniprogram",
+    "sfc",
+    "vue",
+    "weapp",
+    "webpack",
+    "webpack-plugin",
+    "wxml"
+  ],
+  "homepage": "https://github.com/into-mini/into-mini/tree/master/packages/sfc-split-plugin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/into-mini/into-mini.git",
+    "directory": "packages/sfc-split-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/into-mini/into-mini/issues"
+  },
+  "main": "plugin.mjs",
+  "files": [
+    "**/*.json",
+    "**/*.mjs"
+  ],
+  "type": "module",
+  "dependencies": {
+    "slash": "^5.1.0",
+    "webpack-virtual-modules": "^0.6.2",
+    "yaml": "^2.8.2",
+    "yaml-patch-loader": "^0.1.0",
+    "@into-mini/clsx": "^0.1.0",
+    "@into-mini/sfc-transformer": "^0.5.12",
+    "@into-mini/wxml-loader": "^0.0.0"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.28.5",
+    "webpack": "^5.103.0"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/plugin/add-entry.mjs

@@ -0,0 +1,85 @@
+export class AddEntryPlugin {
+  PLUGIN_NAME = 'AddEntryPlugin';
+
+  #addSmartEntry({ name, path, layer }) {
+    if (this.compiler.__entries__.get(name) !== path) {
+      this.compiler.__entries__.set(name, { path, layer });
+    }
+  }
+
+  #addEntries(compilation) {
+    const { compiler } = this;
+
+    const { createDependency } = compiler.webpack.EntryPlugin;
+
+    compilation.hooks.buildModule.tap(this.PLUGIN_NAME, () => {
+      for (const [name, { path, layer }] of compiler.__entries__.entries()) {
+        compilation.addEntry(
+          compiler.context,
+          createDependency(path, { name }),
+          {
+            name,
+            import: [path],
+            layer,
+          },
+          (err) => {
+            if (err) {
+              throw err;
+            } else {
+              compilation.fileDependencies.add(path);
+            }
+          },
+        );
+      }
+    });
+  }
+
+  #expose(compiler) {
+    this.compiler = compiler;
+
+    const { PLUGIN_NAME } = this;
+
+    const {
+      NormalModule: { getCompilationHooks },
+    } = compiler.webpack;
+
+    Object.defineProperty(compiler, 'addSmartEntry', {
+      enumerable: true,
+      configurable: false,
+      value: (options) => {
+        this.#addSmartEntry(options);
+      },
+    });
+
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      getCompilationHooks(compilation).loader.tap(
+        PLUGIN_NAME,
+        (loaderContext) => {
+          Object.defineProperty(loaderContext, 'addSmartEntry', {
+            enumerable: true,
+            configurable: false,
+            value: (options) => {
+              this.#addSmartEntry(options);
+            },
+          });
+        },
+      );
+    });
+  }
+
+  apply(compiler) {
+    this.#expose(compiler);
+
+    const { PLUGIN_NAME } = this;
+
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      this.#addEntries(compilation);
+    });
+    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+      this.#addEntries(compilation);
+    });
+    compiler.hooks.make.tap(PLUGIN_NAME, (compilation) => {
+      this.#addEntries(compilation);
+    });
+  }
+}

package/plugin/add-wxs.mjs

@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs';
+import { extname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { CLSX_PLACEHOLDER } from '@into-mini/sfc-transformer/utils.mjs';
+import slash from 'slash';
+
+// WXS文件输出路径
+const WXS_FILENAME = 'wxs/clsx.wxs';
+
+/**
+ * 将clsx.wxs文件添加到编译结果中，并替换WXML文件中的占位符。
+ * 只在发现CLSX_PLACEHOLDER时添加wxs文件，且只添加一次。
+ */
+export class AddWxsPlugin {
+  PLUGIN_NAME = 'AddWxsPlugin';
+
+  apply(compiler) {
+    const { RawSource } = compiler.webpack.sources;
+
+    compiler.hooks.compilation.tap(this.PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tap(
+        {
+          name: this.PLUGIN_NAME,
+          stage: compilation.constructor.PROCESS_ASSETS_STAGE_ADDITIONAL,
+        },
+        (assets) => this.#processAssets(assets, compilation, RawSource),
+      );
+    });
+  }
+
+  #processAssets(assets, compilation, RawSource) {
+    // 处理所有wxml文件
+    for (const [filename, source] of Object.entries(assets)) {
+      if (extname(filename) === '.wxml') {
+        const content = source.source().toString();
+
+        if (content.includes(CLSX_PLACEHOLDER)) {
+          this.#addWxsFile(compilation, RawSource);
+
+          this.#replaceSource(compilation, RawSource, {
+            filename,
+            content,
+          });
+        }
+      }
+    }
+  }
+
+  #replaceSource(compilation, RawSource, { filename, content }) {
+    const relativePath = slash(relative(join(filename, '..'), WXS_FILENAME));
+    const newContent = content.replace(CLSX_PLACEHOLDER, relativePath);
+    compilation.updateAsset(filename, new RawSource(newContent));
+  }
+
+  #addWxsFile(compilation, RawSource) {
+    const wxsPath = import.meta.resolve('@into-mini/clsx/index.wxs');
+    const wxsContent = readFileSync(fileURLToPath(wxsPath), 'utf8');
+
+    compilation.emitAsset(WXS_FILENAME, new RawSource(wxsContent));
+  }
+}

package/plugin/copy-config.mjs

@@ -0,0 +1,89 @@
+import { fileURLToPath } from 'node:url';
+
+import { patchConfig } from '../helper/index.mjs';
+import { configKeys } from '../helper/utils.mjs';
+
+function reach(path) {
+  return fileURLToPath(import.meta.resolve(path));
+}
+
+const emptyJSON = reach('../helper/empty.json');
+const yamlLoader = reach('yaml-patch-loader');
+
+export class CopyConfigPlugin {
+  constructor({ type = false } = {}) {
+    this.type = type;
+  }
+
+  addConfigSmartEntry({
+    layer,
+    from = layer,
+    name = layer,
+    filename = from,
+    options,
+  }) {
+    const path = `./${from}.yaml`;
+
+    this.compiler.options.entry[name] = {
+      import: [path],
+      layer,
+      runtime: false,
+      filename,
+    };
+
+    this.compiler.options.resolve.fallback[path] = emptyJSON;
+
+    this.compiler.options.module.rules.push({
+      issuerLayer: layer,
+      loader: yamlLoader,
+      type: 'asset/resource',
+      generator: {
+        filename: `${filename}.json`,
+      },
+      options,
+    });
+  }
+
+  apply(compiler) {
+    const { type } = this;
+    this.compiler = compiler;
+
+    if (type) {
+      this.addConfigSmartEntry({
+        layer: configKeys.project,
+        options: {
+          modify: (json) => ({
+            srcMiniprogramRoot: '',
+            miniprogramRoot: '',
+            pluginRoot: '',
+            ...json,
+            compileType: type,
+          }),
+        },
+      });
+
+      this.addConfigSmartEntry({
+        layer: configKeys.projectPrivate,
+      });
+
+      if (this.type === 'miniprogram') {
+        this.addConfigSmartEntry({
+          layer: configKeys.app,
+          from: 'app',
+          options: {
+            modify: patchConfig,
+          },
+        });
+
+        this.compiler.options.entry.app = {
+          import: ['./app'],
+        };
+
+        // this.compiler.options.entry.__hack__ = {
+        //   import: [reach('../helper/hack.hack')],
+        //   layer: configKeys.hack,
+        // };
+      }
+    }
+  }
+}

package/plugin/emit-fake.mjs

@@ -0,0 +1,35 @@
+import { COMPONENT_ROOT } from '../helper/index.mjs';
+
+const files = {
+  '/fake.json': '{}',
+  '/fake.js': '/**用于创建分包的假页面**/',
+  '/fake.wxml': '<!--用于创建分包的假页面-->',
+};
+
+export class EmitFakePlugin {
+  PLUGIN_NAME = 'EmitFakePlugin';
+
+  apply(compiler) {
+    const {
+      sources: { RawSource },
+      Compilation: { PROCESS_ASSETS_STAGE_ADDITIONAL },
+    } = compiler.webpack;
+
+    compiler.hooks.make.tap(this.PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tap(
+        {
+          name: this.PLUGIN_NAME,
+          stage: PROCESS_ASSETS_STAGE_ADDITIONAL,
+        },
+        () => {
+          for (const [path, content] of Object.entries(files)) {
+            compilation.emitAsset(
+              COMPONENT_ROOT + path,
+              new RawSource(content),
+            );
+          }
+        },
+      );
+    });
+  }
+}

package/plugin/expose-entry-bk.mjs

@@ -0,0 +1,73 @@
+import slash from 'slash';
+const PLUGIN_NAME = 'ExposeEntryNamePlugin';
+export class ExposeEntryNamePlugin {
+  getEntryNameFromEntries(compilation, module) {
+    const { moduleGraph, entries } = compilation;
+    for (const [name, io] of entries) {
+      for (const dep of io.dependencies) {
+        const entryModule = moduleGraph.getModule(dep);
+        if (entryModule) {
+          if (
+            // @ts-expect-error ------------
+            entryModule.request && // @ts-expect-error ------------
+            slash(entryModule.request) === slash(module.request)
+          ) {
+            return name;
+          }
+          if (
+            // @ts-expect-error ------------
+            entryModule?.resource && // @ts-expect-error ------------
+            slash(entryModule?.resource) === slash(module.resource)
+          ) {
+            return name;
+          }
+        }
+      }
+    }
+    return '';
+  }
+  getEntryNameFromPathData(compilation, pathData) {
+    const mod = pathData.module;
+    const graph = pathData.chunkGraph;
+    if (mod && graph) {
+      const [entryModule] = graph
+        .getModuleChunks(mod)
+        .map((chunk) => [...graph.getChunkEntryModulesIterable(chunk)][0]);
+      if (entryModule) {
+        return this.getEntryNameFromEntries(compilation, entryModule);
+      }
+    }
+    return '';
+  }
+  apply(compiler) {
+    const {
+      NormalModule: { getCompilationHooks },
+    } = compiler.webpack;
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.assetPath.tap(PLUGIN_NAME, (path, pathData) => {
+        if (path.includes('[entry]')) {
+          const entryName = this.getEntryNameFromPathData(
+            compilation,
+            pathData,
+          );
+          return entryName
+            ? path.replaceAll('[entry]', entryName)
+            : path.replaceAll('[entry]', '[hash:8]');
+        }
+        return path;
+      });
+      getCompilationHooks(compilation).loader.tap(
+        PLUGIN_NAME,
+        (loaderContext, module) => {
+          Object.defineProperty(loaderContext, 'entryName', {
+            enumerable: true,
+            configurable: false,
+            get: () => {
+              return this.getEntryNameFromEntries(compilation, module);
+            },
+          });
+        },
+      );
+    });
+  }
+}

package/plugin/expose-entry.mjs

@@ -0,0 +1,86 @@
+import slash from 'slash';
+const PLUGIN_NAME = 'ExposeEntryNamePlugin';
+export class ExposeEntryNamePlugin {
+  getEntryNameFromChunk(chunk) {
+    if (!chunk?.groupsIterable) {
+      return '';
+    }
+    for (const group of chunk.groupsIterable) {
+      if (group.isInitial()) {
+        return group.name;
+      }
+    }
+    return '';
+  }
+  getEntryNameFromEntries(compilation, module) {
+    const { moduleGraph, entries } = compilation;
+    for (const [name, io] of entries) {
+      for (const dep of io.dependencies) {
+        const entryModule = moduleGraph.getModule(dep);
+        if (entryModule) {
+          if (
+            // @ts-expect-error ------------
+            entryModule.request && // @ts-expect-error ------------
+            slash(entryModule.request) === slash(module.request)
+          ) {
+            return name;
+          }
+          if (
+            // @ts-expect-error ------------
+            entryModule?.resource && // @ts-expect-error ------------
+            slash(entryModule?.resource) === slash(module.resource)
+          ) {
+            return name;
+          }
+        }
+      }
+    }
+    return '';
+  }
+  getEntryNameFromPathData(pathData) {
+    if (pathData?.chunk) {
+      const entryName = this.getEntryNameFromChunk(pathData.chunk);
+      if (entryName) {
+        return entryName;
+      }
+    }
+    if (pathData?.module && pathData?.chunkGraph) {
+      const chunks = pathData.chunkGraph.getModuleChunks(pathData.module);
+      for (const chunk of chunks) {
+        const entryName = this.getEntryNameFromChunk(chunk);
+        if (entryName) {
+          return entryName;
+        }
+      }
+    }
+    return '';
+  }
+  apply(compiler) {
+    const {
+      NormalModule: { getCompilationHooks },
+    } = compiler.webpack;
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.assetPath.tap(PLUGIN_NAME, (path, pathData) => {
+        if (path.includes('[entry]')) {
+          const entryName = this.getEntryNameFromPathData(pathData);
+          return entryName
+            ? path.replaceAll('[entry]', entryName)
+            : path.replaceAll('[entry]', '[hash:8]');
+        }
+        return path;
+      });
+      getCompilationHooks(compilation).loader.tap(
+        PLUGIN_NAME,
+        (loaderContext, module) => {
+          Object.defineProperty(loaderContext, 'entryName', {
+            enumerable: true,
+            configurable: false,
+            get: () => {
+              return this.getEntryNameFromEntries(compilation, module);
+            },
+          });
+        },
+      );
+    });
+  }
+}

package/plugin/find-entry.mjs

@@ -0,0 +1,111 @@
+import { extname } from 'node:path';
+
+import {
+  createAddEntry,
+  createEmitFile,
+  readAndTrack,
+} from '../helper/hooks.mjs';
+import { getAllPages } from '../helper/index.mjs';
+
+/**
+ * Webpack插件，用于处理小程序和插件的入口文件
+ */
+export class FindEntryPlugin {
+  PLUGIN_NAME = 'FindEntryPlugin';
+
+  /**
+   * @param {Object} options - 插件配置选项
+   * @param {string} [options.type=false] - 项目类型，可选值：'miniprogram'或'plugin'
+   */
+  constructor({ type = false } = {}) {
+    this.type = type;
+  }
+
+  /**
+   * 处理Vue页面入口
+   * @private
+   */
+  #handleVuePages(params, pages, basePath = '.') {
+    const { addEntry, compilation } = params;
+
+    for (const page of pages) {
+      const source = `${basePath}/${page}.vue`;
+      addEntry(page, source);
+      compilation.fileDependencies.add(source);
+    }
+  }
+
+  /**
+   * 处理插件页面和组件
+   * @private
+   */
+  #handlePluginSection(params, config, section) {
+    const entries = config[section];
+
+    if (!entries) {
+      return;
+    }
+
+    Object.entries(entries).forEach(([key, path]) => {
+      if (typeof path === 'string' && extname(path) === '.vue') {
+        const source = `${section}/${key}/index`;
+        params.addEntry(source, path);
+        params.compilation.fileDependencies.add(path);
+
+        if (section === 'pages') {
+          config.pages = config.pages || {};
+          config.pages[key] = source;
+        }
+      }
+    });
+  }
+
+  /**
+   * 处理配置和入口
+   * @private
+   */
+  #processConfig(params, configType) {
+    const { readFrom, emitFile, addEntry, compilation } = params;
+    const { content: config, name } = readFrom(
+      configType === 'miniprogram' ? 'app' : configType,
+    );
+
+    if (configType === 'miniprogram') {
+      this.#handleVuePages(params, getAllPages(config));
+    } else if (configType === 'plugin') {
+      if (config.main) {
+        addEntry('main', config.main);
+        compilation.fileDependencies.add(config.main);
+        config.main = 'main.js';
+      }
+
+      this.#handlePluginSection(params, config, 'pages');
+      this.#handlePluginSection(params, config, 'publicComponents');
+      emitFile(name, config);
+    }
+  }
+
+  apply(compiler) {
+    const {
+      sources: { RawSource },
+    } = compiler.webpack;
+
+    const addEntry = createAddEntry(compiler);
+
+    // 处理入口文件和配置
+    compiler.hooks.compilation.tap(this.PLUGIN_NAME, (compilation) => {
+      const params = {
+        compilation,
+        addEntry,
+        emitFile: createEmitFile({
+          PLUGIN_NAME: this.PLUGIN_NAME,
+          compilation,
+          RawSource,
+        }),
+        readFrom: readAndTrack(compiler, compilation),
+      };
+
+      this.#processConfig(params, this.type);
+    });
+  }
+}

package/plugin/mina-runtime.mjs

@@ -0,0 +1,58 @@
+import { dirname, relative, sep } from 'node:path';
+
+const PLUGIN_NAME = 'MinaRuntimeWebpackPlugin';
+
+export class MinaRuntimeWebpackPlugin {
+  // 格式化依赖路径为require语句
+  #formatRequire = (from, to) =>
+    `require('./${relative(dirname(from), to).split(sep).join('/')}');\n`;
+
+  // 收集并生成所有依赖的require语句
+  #generateDependencies = (chunk) => {
+    if (!chunk?.name) {
+      return '';
+    }
+
+    let result = '';
+
+    for (const { chunks } of chunk.groupsIterable) {
+      for (const depChunk of chunks) {
+        if (depChunk !== chunk && depChunk.name) {
+          result += this.#formatRequire(chunk.name, depChunk.name);
+        }
+      }
+    }
+
+    return result;
+  };
+
+  apply(compiler) {
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      const {
+        javascript: { JavascriptModulesPlugin },
+        sources: { ConcatSource },
+      } = compiler.webpack;
+
+      JavascriptModulesPlugin.getCompilationHooks(compilation).renderChunk.tap(
+        PLUGIN_NAME,
+        (source, { chunk }) => {
+          if (
+            !chunk ||
+            !compilation.chunkGraph.getNumberOfEntryModules(chunk)
+          ) {
+            // 跳过非入口模块
+            return source;
+          }
+
+          const deps = this.#generateDependencies(chunk);
+
+          if (!deps) {
+            return source;
+          }
+
+          return new ConcatSource(deps, source);
+        },
+      );
+    });
+  }
+}

package/plugin/sfc-split.mjs

@@ -0,0 +1,102 @@
+import path from 'node:path';
+
+import { parse } from '@into-mini/sfc-transformer';
+import slash from 'slash';
+import VirtualModulesPlugin from 'webpack-virtual-modules';
+
+export class SfcSplitPlugin extends VirtualModulesPlugin {
+  PLUGIN_NAME = 'SfcSplitPlugin';
+
+  constructor({ tagMatcher, preserveTap }) {
+    super();
+    this.tagMatcher = tagMatcher;
+    this.preserveTap = preserveTap;
+  }
+
+  apply(compiler) {
+    this.#expose(compiler);
+
+    super.apply(compiler);
+  }
+
+  #expose(compiler) {
+    const { PLUGIN_NAME } = this;
+
+    const {
+      NormalModule: { getCompilationHooks },
+    } = compiler.webpack;
+
+    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+      getCompilationHooks(compilation).loader.tap(
+        PLUGIN_NAME,
+        (loaderContext) => {
+          Object.defineProperty(loaderContext, 'processSfcFile', {
+            enumerable: true,
+            configurable: false,
+            value: (options) => {
+              return this.#processSfcFile(options);
+            },
+          });
+        },
+      );
+    });
+  }
+
+  #inject(resourcePath, ext, content) {
+    const src = path.resolve(resourcePath.replace(/\.vue$/, ext));
+
+    super.writeModule(src, content);
+
+    return src;
+  }
+
+  #injectStyle(resourcePath, id, style) {
+    return this.#inject(
+      resourcePath,
+      `-${id}.${style.lang ?? 'css'}`,
+      style.content,
+    );
+  }
+
+  #injectStyles(resourcePath, styles) {
+    const io = [];
+
+    const css = styles?.length > 0 ? styles : [];
+
+    css.forEach((style, idx) => {
+      if (style?.content) {
+        const src = this.#injectStyle(resourcePath, idx, style);
+        io.push(src);
+      }
+    });
+
+    return io;
+  }
+
+  #injectTemplate(resourcePath, tpl) {
+    return this.#inject(resourcePath, '.wxml', tpl);
+  }
+
+  #processSfcFile({ source, resourcePath }) {
+    const { tagMatcher, preserveTap } = this;
+
+    const { tpl, styles, code, config } = parse(source, {
+      tagMatcher,
+      preserveTap,
+    });
+
+    const paths = [];
+
+    const wxml = this.#injectTemplate(resourcePath, tpl);
+    paths.push(wxml);
+
+    const css = this.#injectStyles(resourcePath, styles);
+    paths.push(...css);
+
+    return {
+      config,
+      paths: paths.map((src) => slash(src)),
+      script: code,
+    };
+  }
+}

package/plugin.mjs

@@ -0,0 +1,96 @@
+/* eslint-disable no-param-reassign */
+import { fileURLToPath } from 'node:url';
+
+import { COMPONENT_ROOT } from './helper/index.mjs';
+import { configKeys } from './helper/utils.mjs';
+import { AddEntryPlugin } from './plugin/add-entry.mjs';
+import { AddWxsPlugin } from './plugin/add-wxs.mjs';
+import { CopyConfigPlugin } from './plugin/copy-config.mjs';
+import { EmitFakePlugin } from './plugin/emit-fake.mjs';
+import { ExposeEntryNamePlugin } from './plugin/expose-entry.mjs';
+import { FindEntryPlugin } from './plugin/find-entry.mjs';
+import { SfcSplitPlugin } from './plugin/sfc-split.mjs';
+import { MinaRuntimeWebpackPlugin } from './plugin/mina-runtime.mjs';
+
+function reach(path) {
+  return fileURLToPath(import.meta.resolve(path));
+}
+
+export class AllInOnePlugin {
+  constructor({ type = false, tagMatcher, preserveTap } = {}) {
+    this.type = type;
+    this.tagMatcher = tagMatcher;
+    this.preserveTap = preserveTap;
+  }
+
+  #applyLoader(compiler) {
+    compiler.options.module.rules.push(
+      // {
+      //   exclude: /\.(vue|wxml)$/,
+      //   layer: 'other',
+      // },
+      {
+        test: /\.vue$/,
+        loader: reach('./loader/fake-vue-loader.mjs'),
+        options: {
+          componentRoot: COMPONENT_ROOT,
+        },
+      },
+      {
+        test: /\.wxml$/,
+        type: 'asset/resource',
+        loader: reach('@into-mini/wxml-loader'),
+        generator: {
+          filename: '[entry][ext]',
+        },
+      },
+      {
+        test: /\.hack$/,
+        type: 'javascript/esm',
+        layer: configKeys.hack,
+        loader: reach('./loader/hack-entry-loader.mjs'),
+      },
+    );
+  }
+
+  #prepare(compiler) {
+    compiler.options.resolve.extensionAlias ??= {};
+
+    compiler.options.resolve.extensionAlias['.yaml'] = [
+      '.yaml',
+      '.yml',
+      '.json',
+    ];
+
+    compiler.options.resolve.fallback ??= {};
+
+    if (compiler.options.entry?.main) {
+      delete compiler.options.entry.main;
+    }
+
+    Object.assign(compiler, {
+      __entries__: new Map(),
+    });
+  }
+
+  apply(compiler) {
+    this.#prepare(compiler);
+    this.#applyLoader(compiler);
+
+    const { type, tagMatcher, preserveTap } = this;
+
+    if (type) {
+      new MinaRuntimeWebpackPlugin().apply(compiler);
+      new AddEntryPlugin().apply(compiler);
+      new AddWxsPlugin().apply(compiler);
+      new SfcSplitPlugin({ tagMatcher, preserveTap }).apply(compiler);
+      new ExposeEntryNamePlugin().apply(compiler);
+      new FindEntryPlugin({ type }).apply(compiler);
+      new CopyConfigPlugin({ type }).apply(compiler);
+    }
+
+    if (type === 'miniprogram') {
+      new EmitFakePlugin().apply(compiler);
+    }
+  }
+}