@codespark/plugin-webpack 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TonyL1u
+
+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/README.md

@@ -0,0 +1,91 @@
+# @codespark/plugin-webpack
+
+Webpack plugin for the [Codespark](https://codesparkjs.com) ecosystem. Automatically collects dependency information from JSX code at build time.
+
+## Documentation
+
+Visit [https://codesparkjs.com/docs/plugin/webpack](https://codesparkjs.com/docs/plugin/webpack) to view the documentation.
+
+## Installation
+
+```bash
+npm install @codespark/plugin-webpack
+# or
+pnpm add @codespark/plugin-webpack
+```
+
+## Usage
+
+### Webpack
+
+```js
+// webpack.config.js
+import CodesparkWebpackPlugin from '@codespark/plugin-webpack';
+
+export default {
+  plugins: [
+    new CodesparkWebpackPlugin()
+  ]
+};
+```
+
+### Next.js (Webpack)
+
+```js
+// next.config.ts
+import type { NextConfig } from 'next';
+import CodesparkWebpackPlugin from '@codespark/plugin-webpack';
+
+const nextConfig: NextConfig = {
+  /* config options here */
+  webpack(config) {
+    config.plugins.push(new CodesparkWebpackPlugin());
+
+    return config;
+  }
+};
+
+export default nextConfig;
+```
+
+### Next.js (Turbopack)
+
+```ts
+// next.config.ts
+const nextConfig: NextConfig = {
+  /* config options here */
+  turbopack: {
+    rules: {
+      '*.tsx': {
+        loaders: [
+          {
+            loader: '@codespark/plugin-webpack/loader'
+          }
+        ]
+      }
+    }
+  }
+};
+
+export default nextConfig;
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enabled` | `boolean` | `true` | Enable/disable the plugin |
+| `methods` | `string[]` | `['createWorkspace']` | Method names to transform |
+| `importSource` | `string[]` | `['@codespark/react']` | Package names to detect imports from |
+
+```js
+new CodesparkWebpackPlugin({
+  enabled: true,
+  methods: ['createWorkspace'],
+  importSource: ['@codespark/react']
+})
+```
+
+## License
+
+MIT

package/dist/chunk-CbDLau6x.cjs

@@ -0,0 +1,34 @@
+//#region rolldown:runtime
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, 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));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/index.cjs

@@ -0,0 +1,32 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_url = require("node:url");
+
+//#region src/index.ts
+const __dir = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+const loaderPath = node_path.default.resolve(__dir, "loader.mjs");
+var CodesparkWebpackPlugin = class {
+	enabled;
+	methods;
+	constructor(options) {
+		const { enabled = true, methods } = options || {};
+		this.enabled = enabled;
+		this.methods = methods;
+	}
+	apply(compiler) {
+		if (!this.enabled) return;
+		compiler.options.module.rules.push({
+			test: /\.(js|jsx|ts|tsx)$/,
+			exclude: /node_modules/,
+			enforce: "pre",
+			use: [{
+				loader: loaderPath,
+				options: { methods: this.methods }
+			}]
+		});
+	}
+};
+
+//#endregion
+module.exports = CodesparkWebpackPlugin;

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+import { Compiler } from "webpack";
+
+//#region src/index.d.ts
+interface Options {
+  enabled?: boolean;
+  methods?: string[];
+}
+declare class CodesparkWebpackPlugin {
+  private enabled;
+  private methods?;
+  constructor(options?: Options);
+  apply(compiler: Compiler): void;
+}
+//#endregion
+export { Options, CodesparkWebpackPlugin as default };

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+import { Compiler } from "webpack";
+
+//#region src/index.d.ts
+interface Options {
+  enabled?: boolean;
+  methods?: string[];
+}
+declare class CodesparkWebpackPlugin {
+  private enabled;
+  private methods?;
+  constructor(options?: Options);
+  apply(compiler: Compiler): void;
+}
+//#endregion
+export { Options, CodesparkWebpackPlugin as default };

package/dist/index.mjs

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/index.ts
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+const loaderPath = path.resolve(__dir, "loader.mjs");
+var CodesparkWebpackPlugin = class {
+	enabled;
+	methods;
+	constructor(options) {
+		const { enabled = true, methods } = options || {};
+		this.enabled = enabled;
+		this.methods = methods;
+	}
+	apply(compiler) {
+		if (!this.enabled) return;
+		compiler.options.module.rules.push({
+			test: /\.(js|jsx|ts|tsx)$/,
+			exclude: /node_modules/,
+			enforce: "pre",
+			use: [{
+				loader: loaderPath,
+				options: { methods: this.methods }
+			}]
+		});
+	}
+};
+
+//#endregion
+export { CodesparkWebpackPlugin as default };

package/dist/loader.cjs

@@ -0,0 +1,329 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let __babel_generator = require("@babel/generator");
+__babel_generator = require_chunk.__toESM(__babel_generator);
+let __babel_parser = require("@babel/parser");
+let __babel_traverse = require("@babel/traverse");
+__babel_traverse = require_chunk.__toESM(__babel_traverse);
+let __babel_types = require("@babel/types");
+__babel_types = require_chunk.__toESM(__babel_types);
+
+//#region src/collect-deps.ts
+const pkgPath = process.cwd();
+const pathsConfig = JSON.parse(node_fs.default.readFileSync(node_path.default.resolve(pkgPath, "tsconfig.json"), "utf-8")).compilerOptions?.paths || {};
+const aliases = Object.keys(pathsConfig).map((p) => p.replace("/*", ""));
+function parseCode(code) {
+	return (0, __babel_parser.parse)(code, {
+		sourceType: "module",
+		plugins: ["jsx", "typescript"]
+	}).program.body;
+}
+function collectIdentifiers(ast) {
+	const ids = /* @__PURE__ */ new Set();
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "Identifier" || node.type === "JSXIdentifier") ids.add(node.name);
+		for (const key of Object.keys(node)) {
+			if (key === "loc" || key === "range") continue;
+			const value = node[key];
+			if (Array.isArray(value)) value.forEach(walk);
+			else if (value && typeof value === "object") walk(value);
+		}
+	}
+	ast.forEach(walk);
+	return ids;
+}
+function buildImportMap(imports) {
+	const map = /* @__PURE__ */ new Map();
+	for (const imp of imports) {
+		if (imp.importKind === "type") continue;
+		const source = imp.source.value;
+		for (const spec of imp.specifiers) {
+			if (spec.type === "ImportSpecifier" && spec.importKind === "type") continue;
+			map.set(spec.local.name, source);
+		}
+	}
+	return map;
+}
+function getUsedSources(usedIds, importMap) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const id of usedIds) {
+		const source = importMap.get(id);
+		if (source) sources.add(source);
+	}
+	return sources;
+}
+function getDefinedNames(node) {
+	if (node.type === "ExportNamedDeclaration" && node.declaration) return getDefinedNames(node.declaration);
+	if (node.type === "VariableDeclaration") return node.declarations.flatMap((d) => d.id.type === "Identifier" ? [d.id.name] : []);
+	if (node.type === "FunctionDeclaration" && node.id) return [node.id.name];
+	if (node.type === "ClassDeclaration" && node.id) return [node.id.name];
+	return [];
+}
+function findMatchingAlias(source) {
+	for (const alias of aliases) if (source === alias || source.startsWith(alias + "/")) return alias;
+	return null;
+}
+function resolveAlias(source) {
+	const alias = findMatchingAlias(source);
+	if (!alias) return source;
+	const aliasPath = pathsConfig[alias + "/*"][0].replace("/*", "");
+	return source.replace(alias, node_path.default.resolve(pkgPath, aliasPath));
+}
+function resolveFile$1(source, fromFile) {
+	const resolved = source.startsWith(".") ? node_path.default.resolve(node_path.default.dirname(fromFile), source) : resolveAlias(source);
+	for (const ext of [
+		".tsx",
+		".ts",
+		".jsx",
+		".js",
+		"/index.tsx",
+		"/index.ts"
+	]) {
+		const tryPath = resolved + ext;
+		if (node_fs.default.existsSync(tryPath)) return tryPath;
+	}
+	return node_fs.default.existsSync(resolved) ? resolved : null;
+}
+function isLocalImport(source) {
+	if (source.startsWith(".") || source.startsWith("/")) return true;
+	return findMatchingAlias(source) !== null;
+}
+function isAliasImport(source) {
+	return !source.startsWith(".") && !source.startsWith("/") && findMatchingAlias(source) !== null;
+}
+function aliasToRelative(source, resolved) {
+	const alias = findMatchingAlias(source);
+	if (!alias) return source;
+	if (source === alias) return ".";
+	let rel = "./" + source.slice(alias.length + 1);
+	if (resolved) {
+		const ext = node_path.default.extname(resolved);
+		if (ext && !rel.endsWith(ext)) rel += ext;
+	}
+	return rel;
+}
+function rewriteAliasImports(code, filePath) {
+	let result = code;
+	const ast = parseCode(code);
+	for (const node of ast) {
+		if (node.type !== "ImportDeclaration") continue;
+		const source = node.source.value;
+		if (!isAliasImport(source)) continue;
+		const resolved = resolveFile$1(source, filePath);
+		if (!resolved) continue;
+		let rel = node_path.default.relative(node_path.default.dirname(filePath), resolved);
+		if (!rel.startsWith(".")) rel = "./" + rel;
+		result = result.replace(`'${source}'`, `'${rel}'`);
+		result = result.replace(`"${source}"`, `"${rel}"`);
+	}
+	return result;
+}
+function collectFromFile(file, usedSources, result, visited) {
+	if (visited.has(file)) return;
+	visited.add(file);
+	const imports = parseCode(node_fs.default.readFileSync(file, "utf-8")).filter((node) => node.type === "ImportDeclaration");
+	for (const imp of imports) {
+		if (imp.importKind === "type") continue;
+		const source = imp.source.value;
+		if (!usedSources.has(source) || !isLocalImport(source)) continue;
+		const resolved = resolveFile$1(source, file);
+		if (!resolved || result[source]) continue;
+		const childCode = node_fs.default.readFileSync(resolved, "utf-8");
+		const childAst = parseCode(childCode);
+		const childImports = childAst.filter((n) => n.type === "ImportDeclaration");
+		const childUsedSources = getUsedSources(collectIdentifiers(childAst.filter((n) => n.type !== "ImportDeclaration")), buildImportMap(childImports));
+		const externals = childImports.filter((i) => i.importKind !== "type" && !isLocalImport(i.source.value) && childUsedSources.has(i.source.value)).map((i) => i.source.value);
+		result[source] = {
+			code: rewriteAliasImports(childCode, resolved),
+			resolved,
+			externals
+		};
+		collectFromFile(resolved, childUsedSources, result, visited);
+	}
+}
+function formatSpecifierName(spec) {
+	if (spec.type === "ImportDefaultSpecifier") return spec.local.name;
+	if (spec.type === "ImportNamespaceSpecifier") return `* as ${spec.local.name}`;
+	const imported = spec.imported;
+	return imported && "name" in imported && imported.name !== spec.local.name ? `${imported.name} as ${spec.local.name}` : spec.local.name;
+}
+function generateImportStatement(imp, usedIds, sourcePath) {
+	const usedSpecifiers = imp.specifiers.filter((s) => usedIds.has(s.local.name));
+	if (usedSpecifiers.length === 0) return null;
+	const parts = [];
+	const namedImports = [];
+	for (const spec of usedSpecifiers) {
+		const name = formatSpecifierName(spec);
+		if (spec.type === "ImportDefaultSpecifier") parts.unshift(name);
+		else if (spec.type === "ImportNamespaceSpecifier") parts.push(name);
+		else namedImports.push(name);
+	}
+	if (namedImports.length > 0) parts.push(`{ ${namedImports.join(", ")} }`);
+	const source = sourcePath ?? imp.source.value;
+	return `import ${parts.join(", ")} from '${source}';`;
+}
+function isUsedImport(imp, usedSources) {
+	return imp.importKind !== "type" && usedSources.has(imp.source.value);
+}
+function collectDependencies(code, hostFile) {
+	const fileInfos = {};
+	const file = node_path.default.resolve(hostFile);
+	const visited = /* @__PURE__ */ new Set();
+	try {
+		const codeUsedIds = collectIdentifiers(parseCode(code));
+		const hostContent = node_fs.default.readFileSync(file, "utf-8");
+		const hostAst = parseCode(hostContent);
+		const hostImports = hostAst.filter((node) => node.type === "ImportDeclaration");
+		const importedNames = new Set(buildImportMap(hostImports).keys());
+		const localDefs = /* @__PURE__ */ new Map();
+		for (const node of hostAst) {
+			if (node.type === "ImportDeclaration") continue;
+			for (const name of getDefinedNames(node)) if (!importedNames.has(name)) localDefs.set(name, {
+				node,
+				code: hostContent.slice(node.start, node.end)
+			});
+		}
+		function collectLocalDeps(ids, collected) {
+			for (const id of ids) {
+				if (collected.has(id) || !localDefs.has(id)) continue;
+				collected.add(id);
+				collectLocalDeps(collectIdentifiers([localDefs.get(id).node]), collected);
+			}
+		}
+		const collectedNames = /* @__PURE__ */ new Set();
+		collectLocalDeps(codeUsedIds, collectedNames);
+		const locals = [];
+		for (const node of hostAst) {
+			if (node.type === "ImportDeclaration") continue;
+			if (getDefinedNames(node).some((name) => collectedNames.has(name))) locals.push(hostContent.slice(node.start, node.end));
+		}
+		const allUsedIds = new Set(codeUsedIds);
+		for (const name of collectedNames) {
+			const def = localDefs.get(name);
+			if (def) for (const id of collectIdentifiers([def.node])) allUsedIds.add(id);
+		}
+		const usedSources = getUsedSources(allUsedIds, buildImportMap(hostImports));
+		collectFromFile(file, usedSources, fileInfos, visited);
+		const files = {};
+		for (const [source, info] of Object.entries(fileInfos)) {
+			const key = isAliasImport(source) ? aliasToRelative(source, info.resolved) : source;
+			files[key] = info.code;
+		}
+		const aliasImports = [];
+		for (const imp of hostImports) {
+			if (!isUsedImport(imp, usedSources) || !isAliasImport(imp.source.value)) continue;
+			if (!resolveFile$1(imp.source.value, file)) continue;
+			const statement = generateImportStatement(imp, allUsedIds, aliasToRelative(imp.source.value));
+			if (statement) aliasImports.push(statement);
+		}
+		const externalImports = [];
+		for (const imp of hostImports) {
+			if (!isUsedImport(imp, usedSources) || isLocalImport(imp.source.value)) continue;
+			const statement = generateImportStatement(imp, allUsedIds);
+			if (statement) externalImports.push(statement);
+		}
+		return {
+			entry: {
+				code,
+				locals,
+				imports: [...aliasImports, ...externalImports]
+			},
+			files
+		};
+	} catch {
+		return {
+			entry: {
+				code,
+				locals: [],
+				imports: []
+			},
+			files: {}
+		};
+	}
+}
+
+//#endregion
+//#region src/transform-jsx.ts
+const traverse = __babel_traverse.default.default ?? __babel_traverse.default;
+const generate = __babel_generator.default.default ?? __babel_generator.default;
+const resolveFile = (source, fromFile) => {
+	const resolved = node_path.default.resolve(node_path.default.dirname(fromFile), source);
+	for (const ext of [
+		".tsx",
+		".ts",
+		".jsx",
+		".js",
+		"/index.tsx",
+		"/index.ts"
+	]) {
+		const tryPath = resolved + ext;
+		if (node_fs.default.existsSync(tryPath)) return tryPath;
+	}
+	return node_fs.default.existsSync(resolved) ? resolved : null;
+};
+const transformJsx = (code, id, options = {}) => {
+	const { methods = ["createWorkspace"], importSource = ["@codespark/react"] } = options;
+	const ast = (0, __babel_parser.parse)(code, {
+		sourceType: "module",
+		plugins: ["jsx", "typescript"]
+	});
+	const importMap = /* @__PURE__ */ new Map();
+	const localNames = /* @__PURE__ */ new Map();
+	const slice = (node) => code.slice(node.start, node.end);
+	let modified = false;
+	traverse(ast, {
+		ImportDeclaration(nodePath) {
+			const source = nodePath.node.source.value;
+			nodePath.node.specifiers.forEach((spec) => {
+				if (spec.type === "ImportDefaultSpecifier") {
+					const resolved = resolveFile(source, id);
+					if (resolved) importMap.set(spec.local.name, resolved);
+				}
+				if (importSource.includes(source) && spec.type === "ImportSpecifier" && __babel_types.isIdentifier(spec.imported)) {
+					if (methods.includes(spec.imported.name)) localNames.set(spec.local.name, spec.imported.name);
+				}
+			});
+		},
+		CallExpression(nodePath) {
+			const callee = nodePath.node.callee;
+			if (!__babel_types.isIdentifier(callee) || !localNames.has(callee.name)) return;
+			const localName = callee.name;
+			const [codeArg] = nodePath.node.arguments;
+			let scannedValue = null;
+			if (__babel_types.isJSXElement(codeArg) || __babel_types.isJSXFragment(codeArg)) scannedValue = __babel_types.valueToNode(collectDependencies(slice(codeArg), id));
+			else if (__babel_types.isIdentifier(codeArg)) scannedValue = __babel_types.valueToNode(collectDependencies(codeArg.name, id));
+			else if (__babel_types.isArrowFunctionExpression(codeArg) || __babel_types.isFunctionExpression(codeArg)) scannedValue = __babel_types.valueToNode(collectDependencies(slice(codeArg), id));
+			if (scannedValue) {
+				nodePath.replaceWith(__babel_types.callExpression(__babel_types.memberExpression(__babel_types.identifier(localName), __babel_types.identifier("call")), [__babel_types.objectExpression([__babel_types.objectProperty(__babel_types.identifier("__scanned"), scannedValue)]), ...nodePath.node.arguments]));
+				modified = true;
+			}
+		}
+	});
+	if (modified) return generate(ast).code;
+	return null;
+};
+
+//#endregion
+//#region src/loader.ts
+const codesparkLoader = function(source) {
+	const id = this.resourcePath;
+	if (![
+		".js",
+		".jsx",
+		".ts",
+		".tsx"
+	].includes(node_path.default.extname(id))) return source;
+	const { methods, importSource } = this.getOptions();
+	return transformJsx(source, id, {
+		methods,
+		importSource
+	}) ?? source;
+};
+var loader_default = codesparkLoader;
+
+//#endregion
+module.exports = loader_default;

package/dist/loader.d.cts

@@ -0,0 +1,10 @@
+import { LoaderDefinitionFunction } from "webpack";
+
+//#region src/loader.d.ts
+interface LoaderOptions {
+  methods?: string[];
+  importSource?: string[];
+}
+declare const codesparkLoader: LoaderDefinitionFunction<LoaderOptions>;
+//#endregion
+export { LoaderOptions, codesparkLoader as default };

package/dist/loader.d.mts

@@ -0,0 +1,10 @@
+import { LoaderDefinitionFunction } from "webpack";
+
+//#region src/loader.d.ts
+interface LoaderOptions {
+  methods?: string[];
+  importSource?: string[];
+}
+declare const codesparkLoader: LoaderDefinitionFunction<LoaderOptions>;
+//#endregion
+export { LoaderOptions, codesparkLoader as default };

package/dist/loader.mjs

@@ -0,0 +1,323 @@
+import path from "node:path";
+import fs from "node:fs";
+import _generate from "@babel/generator";
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+
+//#region src/collect-deps.ts
+const pkgPath = process.cwd();
+const pathsConfig = JSON.parse(fs.readFileSync(path.resolve(pkgPath, "tsconfig.json"), "utf-8")).compilerOptions?.paths || {};
+const aliases = Object.keys(pathsConfig).map((p) => p.replace("/*", ""));
+function parseCode(code) {
+	return parse(code, {
+		sourceType: "module",
+		plugins: ["jsx", "typescript"]
+	}).program.body;
+}
+function collectIdentifiers(ast) {
+	const ids = /* @__PURE__ */ new Set();
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "Identifier" || node.type === "JSXIdentifier") ids.add(node.name);
+		for (const key of Object.keys(node)) {
+			if (key === "loc" || key === "range") continue;
+			const value = node[key];
+			if (Array.isArray(value)) value.forEach(walk);
+			else if (value && typeof value === "object") walk(value);
+		}
+	}
+	ast.forEach(walk);
+	return ids;
+}
+function buildImportMap(imports) {
+	const map = /* @__PURE__ */ new Map();
+	for (const imp of imports) {
+		if (imp.importKind === "type") continue;
+		const source = imp.source.value;
+		for (const spec of imp.specifiers) {
+			if (spec.type === "ImportSpecifier" && spec.importKind === "type") continue;
+			map.set(spec.local.name, source);
+		}
+	}
+	return map;
+}
+function getUsedSources(usedIds, importMap) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const id of usedIds) {
+		const source = importMap.get(id);
+		if (source) sources.add(source);
+	}
+	return sources;
+}
+function getDefinedNames(node) {
+	if (node.type === "ExportNamedDeclaration" && node.declaration) return getDefinedNames(node.declaration);
+	if (node.type === "VariableDeclaration") return node.declarations.flatMap((d) => d.id.type === "Identifier" ? [d.id.name] : []);
+	if (node.type === "FunctionDeclaration" && node.id) return [node.id.name];
+	if (node.type === "ClassDeclaration" && node.id) return [node.id.name];
+	return [];
+}
+function findMatchingAlias(source) {
+	for (const alias of aliases) if (source === alias || source.startsWith(alias + "/")) return alias;
+	return null;
+}
+function resolveAlias(source) {
+	const alias = findMatchingAlias(source);
+	if (!alias) return source;
+	const aliasPath = pathsConfig[alias + "/*"][0].replace("/*", "");
+	return source.replace(alias, path.resolve(pkgPath, aliasPath));
+}
+function resolveFile$1(source, fromFile) {
+	const resolved = source.startsWith(".") ? path.resolve(path.dirname(fromFile), source) : resolveAlias(source);
+	for (const ext of [
+		".tsx",
+		".ts",
+		".jsx",
+		".js",
+		"/index.tsx",
+		"/index.ts"
+	]) {
+		const tryPath = resolved + ext;
+		if (fs.existsSync(tryPath)) return tryPath;
+	}
+	return fs.existsSync(resolved) ? resolved : null;
+}
+function isLocalImport(source) {
+	if (source.startsWith(".") || source.startsWith("/")) return true;
+	return findMatchingAlias(source) !== null;
+}
+function isAliasImport(source) {
+	return !source.startsWith(".") && !source.startsWith("/") && findMatchingAlias(source) !== null;
+}
+function aliasToRelative(source, resolved) {
+	const alias = findMatchingAlias(source);
+	if (!alias) return source;
+	if (source === alias) return ".";
+	let rel = "./" + source.slice(alias.length + 1);
+	if (resolved) {
+		const ext = path.extname(resolved);
+		if (ext && !rel.endsWith(ext)) rel += ext;
+	}
+	return rel;
+}
+function rewriteAliasImports(code, filePath) {
+	let result = code;
+	const ast = parseCode(code);
+	for (const node of ast) {
+		if (node.type !== "ImportDeclaration") continue;
+		const source = node.source.value;
+		if (!isAliasImport(source)) continue;
+		const resolved = resolveFile$1(source, filePath);
+		if (!resolved) continue;
+		let rel = path.relative(path.dirname(filePath), resolved);
+		if (!rel.startsWith(".")) rel = "./" + rel;
+		result = result.replace(`'${source}'`, `'${rel}'`);
+		result = result.replace(`"${source}"`, `"${rel}"`);
+	}
+	return result;
+}
+function collectFromFile(file, usedSources, result, visited) {
+	if (visited.has(file)) return;
+	visited.add(file);
+	const imports = parseCode(fs.readFileSync(file, "utf-8")).filter((node) => node.type === "ImportDeclaration");
+	for (const imp of imports) {
+		if (imp.importKind === "type") continue;
+		const source = imp.source.value;
+		if (!usedSources.has(source) || !isLocalImport(source)) continue;
+		const resolved = resolveFile$1(source, file);
+		if (!resolved || result[source]) continue;
+		const childCode = fs.readFileSync(resolved, "utf-8");
+		const childAst = parseCode(childCode);
+		const childImports = childAst.filter((n) => n.type === "ImportDeclaration");
+		const childUsedSources = getUsedSources(collectIdentifiers(childAst.filter((n) => n.type !== "ImportDeclaration")), buildImportMap(childImports));
+		const externals = childImports.filter((i) => i.importKind !== "type" && !isLocalImport(i.source.value) && childUsedSources.has(i.source.value)).map((i) => i.source.value);
+		result[source] = {
+			code: rewriteAliasImports(childCode, resolved),
+			resolved,
+			externals
+		};
+		collectFromFile(resolved, childUsedSources, result, visited);
+	}
+}
+function formatSpecifierName(spec) {
+	if (spec.type === "ImportDefaultSpecifier") return spec.local.name;
+	if (spec.type === "ImportNamespaceSpecifier") return `* as ${spec.local.name}`;
+	const imported = spec.imported;
+	return imported && "name" in imported && imported.name !== spec.local.name ? `${imported.name} as ${spec.local.name}` : spec.local.name;
+}
+function generateImportStatement(imp, usedIds, sourcePath) {
+	const usedSpecifiers = imp.specifiers.filter((s) => usedIds.has(s.local.name));
+	if (usedSpecifiers.length === 0) return null;
+	const parts = [];
+	const namedImports = [];
+	for (const spec of usedSpecifiers) {
+		const name = formatSpecifierName(spec);
+		if (spec.type === "ImportDefaultSpecifier") parts.unshift(name);
+		else if (spec.type === "ImportNamespaceSpecifier") parts.push(name);
+		else namedImports.push(name);
+	}
+	if (namedImports.length > 0) parts.push(`{ ${namedImports.join(", ")} }`);
+	const source = sourcePath ?? imp.source.value;
+	return `import ${parts.join(", ")} from '${source}';`;
+}
+function isUsedImport(imp, usedSources) {
+	return imp.importKind !== "type" && usedSources.has(imp.source.value);
+}
+function collectDependencies(code, hostFile) {
+	const fileInfos = {};
+	const file = path.resolve(hostFile);
+	const visited = /* @__PURE__ */ new Set();
+	try {
+		const codeUsedIds = collectIdentifiers(parseCode(code));
+		const hostContent = fs.readFileSync(file, "utf-8");
+		const hostAst = parseCode(hostContent);
+		const hostImports = hostAst.filter((node) => node.type === "ImportDeclaration");
+		const importedNames = new Set(buildImportMap(hostImports).keys());
+		const localDefs = /* @__PURE__ */ new Map();
+		for (const node of hostAst) {
+			if (node.type === "ImportDeclaration") continue;
+			for (const name of getDefinedNames(node)) if (!importedNames.has(name)) localDefs.set(name, {
+				node,
+				code: hostContent.slice(node.start, node.end)
+			});
+		}
+		function collectLocalDeps(ids, collected) {
+			for (const id of ids) {
+				if (collected.has(id) || !localDefs.has(id)) continue;
+				collected.add(id);
+				collectLocalDeps(collectIdentifiers([localDefs.get(id).node]), collected);
+			}
+		}
+		const collectedNames = /* @__PURE__ */ new Set();
+		collectLocalDeps(codeUsedIds, collectedNames);
+		const locals = [];
+		for (const node of hostAst) {
+			if (node.type === "ImportDeclaration") continue;
+			if (getDefinedNames(node).some((name) => collectedNames.has(name))) locals.push(hostContent.slice(node.start, node.end));
+		}
+		const allUsedIds = new Set(codeUsedIds);
+		for (const name of collectedNames) {
+			const def = localDefs.get(name);
+			if (def) for (const id of collectIdentifiers([def.node])) allUsedIds.add(id);
+		}
+		const usedSources = getUsedSources(allUsedIds, buildImportMap(hostImports));
+		collectFromFile(file, usedSources, fileInfos, visited);
+		const files = {};
+		for (const [source, info] of Object.entries(fileInfos)) {
+			const key = isAliasImport(source) ? aliasToRelative(source, info.resolved) : source;
+			files[key] = info.code;
+		}
+		const aliasImports = [];
+		for (const imp of hostImports) {
+			if (!isUsedImport(imp, usedSources) || !isAliasImport(imp.source.value)) continue;
+			if (!resolveFile$1(imp.source.value, file)) continue;
+			const statement = generateImportStatement(imp, allUsedIds, aliasToRelative(imp.source.value));
+			if (statement) aliasImports.push(statement);
+		}
+		const externalImports = [];
+		for (const imp of hostImports) {
+			if (!isUsedImport(imp, usedSources) || isLocalImport(imp.source.value)) continue;
+			const statement = generateImportStatement(imp, allUsedIds);
+			if (statement) externalImports.push(statement);
+		}
+		return {
+			entry: {
+				code,
+				locals,
+				imports: [...aliasImports, ...externalImports]
+			},
+			files
+		};
+	} catch {
+		return {
+			entry: {
+				code,
+				locals: [],
+				imports: []
+			},
+			files: {}
+		};
+	}
+}
+
+//#endregion
+//#region src/transform-jsx.ts
+const traverse = _traverse.default ?? _traverse;
+const generate = _generate.default ?? _generate;
+const resolveFile = (source, fromFile) => {
+	const resolved = path.resolve(path.dirname(fromFile), source);
+	for (const ext of [
+		".tsx",
+		".ts",
+		".jsx",
+		".js",
+		"/index.tsx",
+		"/index.ts"
+	]) {
+		const tryPath = resolved + ext;
+		if (fs.existsSync(tryPath)) return tryPath;
+	}
+	return fs.existsSync(resolved) ? resolved : null;
+};
+const transformJsx = (code, id, options = {}) => {
+	const { methods = ["createWorkspace"], importSource = ["@codespark/react"] } = options;
+	const ast = parse(code, {
+		sourceType: "module",
+		plugins: ["jsx", "typescript"]
+	});
+	const importMap = /* @__PURE__ */ new Map();
+	const localNames = /* @__PURE__ */ new Map();
+	const slice = (node) => code.slice(node.start, node.end);
+	let modified = false;
+	traverse(ast, {
+		ImportDeclaration(nodePath) {
+			const source = nodePath.node.source.value;
+			nodePath.node.specifiers.forEach((spec) => {
+				if (spec.type === "ImportDefaultSpecifier") {
+					const resolved = resolveFile(source, id);
+					if (resolved) importMap.set(spec.local.name, resolved);
+				}
+				if (importSource.includes(source) && spec.type === "ImportSpecifier" && t.isIdentifier(spec.imported)) {
+					if (methods.includes(spec.imported.name)) localNames.set(spec.local.name, spec.imported.name);
+				}
+			});
+		},
+		CallExpression(nodePath) {
+			const callee = nodePath.node.callee;
+			if (!t.isIdentifier(callee) || !localNames.has(callee.name)) return;
+			const localName = callee.name;
+			const [codeArg] = nodePath.node.arguments;
+			let scannedValue = null;
+			if (t.isJSXElement(codeArg) || t.isJSXFragment(codeArg)) scannedValue = t.valueToNode(collectDependencies(slice(codeArg), id));
+			else if (t.isIdentifier(codeArg)) scannedValue = t.valueToNode(collectDependencies(codeArg.name, id));
+			else if (t.isArrowFunctionExpression(codeArg) || t.isFunctionExpression(codeArg)) scannedValue = t.valueToNode(collectDependencies(slice(codeArg), id));
+			if (scannedValue) {
+				nodePath.replaceWith(t.callExpression(t.memberExpression(t.identifier(localName), t.identifier("call")), [t.objectExpression([t.objectProperty(t.identifier("__scanned"), scannedValue)]), ...nodePath.node.arguments]));
+				modified = true;
+			}
+		}
+	});
+	if (modified) return generate(ast).code;
+	return null;
+};
+
+//#endregion
+//#region src/loader.ts
+const codesparkLoader = function(source) {
+	const id = this.resourcePath;
+	if (![
+		".js",
+		".jsx",
+		".ts",
+		".tsx"
+	].includes(path.extname(id))) return source;
+	const { methods, importSource } = this.getOptions();
+	return transformJsx(source, id, {
+		methods,
+		importSource
+	}) ?? source;
+};
+var loader_default = codesparkLoader;
+
+//#endregion
+export { loader_default as default };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@codespark/plugin-webpack",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Webpack plugin for codespark ecosystem",
+  "keywords": [
+    "webpack-plugin",
+    "turbopack-plugin",
+    "codespark"
+  ],
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./loader": {
+      "types": "./dist/loader.d.mts",
+      "import": "./dist/loader.mjs",
+      "require": "./dist/loader.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  },
+  "author": "TonyL1u",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codesparkjs/codespark.git",
+    "directory": "packages/webpack"
+  },
+  "homepage": "https://codesparkjs.com",
+  "dependencies": {
+    "@babel/generator": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@babel/types": "^7.28.5"
+  },
+  "devDependencies": {
+    "@codespark/react": "workspace:*",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/mdx": "^2.0.13",
+    "@types/node": "^22.19.2",
+    "@types/react": "^19.2.7",
+    "tsdown": "^0.17.3",
+    "webpack": "^5.99.9"
+  }
+}