@gravity-ui/data-source 0.10.0-alpha.0 → 0.10.0-alpha.10

package/build/plugin/factory-B49Ym3ij.cjs

@@ -0,0 +1,696 @@
+//#region \0rolldown/runtime.js
+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
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let magic_string = require("magic-string");
+magic_string = __toESM(magic_string);
+let oxc_parser = require("oxc-parser");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let oxc_transform = require("oxc-transform");
+//#region src/plugin/core/utils.ts
+const VIRTUAL_PREFIX = "\0dsl-plugin";
+const COMPANION_TYPES = {
+	loading: "Loading",
+	error: "Error",
+	lazy: "Lazy"
+};
+const COMPANION_TYPE_BY_SUFFIX = {
+	Loading: "loading",
+	Error: "error",
+	Lazy: "lazy"
+};
+const COMPANION_TYPES_SET = new Set(Object.keys(COMPANION_TYPES));
+const COMPANION_SUFFIXES_SET = new Set(Object.values(COMPANION_TYPES));
+function isCompanionType(type) {
+	return COMPANION_TYPES_SET.has(type);
+}
+function isCompanionSuffix(suffix) {
+	return COMPANION_SUFFIXES_SET.has(suffix);
+}
+function makeVirtualId(type, sourceFile) {
+	return `${VIRTUAL_PREFIX}:${type}:${stripQuery(sourceFile)}`;
+}
+function parseVirtualId(id) {
+	const prefixIndex = id.indexOf(VIRTUAL_PREFIX);
+	if (prefixIndex === -1) return null;
+	const rest = id.slice(prefixIndex + 11 + 1);
+	const colonIndex = rest.indexOf(":");
+	if (colonIndex === -1) return null;
+	const type = rest.slice(0, colonIndex);
+	if (!isCompanionType(type)) return null;
+	return {
+		type,
+		sourceFile: rest.slice(colonIndex + 1)
+	};
+}
+function makeCompanionId(type, sourceFile) {
+	const suffix = COMPANION_TYPES[type];
+	const cleanSourceFile = stripQuery(sourceFile);
+	const ext = node_path.default.extname(cleanSourceFile);
+	return `${ext ? cleanSourceFile.slice(0, -ext.length) : cleanSourceFile}.${suffix}${ext}`;
+}
+function parseCompanionId(id) {
+	const suffixIndex = id.lastIndexOf(".");
+	if (suffixIndex === -1) return null;
+	const suffix = id.slice(suffixIndex + 1);
+	if (!isCompanionSuffix(suffix)) return null;
+	return {
+		type: COMPANION_TYPE_BY_SUFFIX[suffix],
+		sourceFile: id.slice(0, suffixIndex)
+	};
+}
+function isRelativeId(id) {
+	return id[0] === ".";
+}
+function toRelativeImportSource(fromFile, toFile) {
+	const fromDir = node_path.default.dirname(stripQuery(fromFile));
+	let rel = node_path.default.relative(fromDir, toFile);
+	if (node_path.default.sep !== "/") rel = rel.split(node_path.default.sep).join("/");
+	if (!rel.startsWith(".")) rel = `./${rel}`;
+	const ext = node_path.default.extname(rel);
+	return ext ? rel.slice(0, -ext.length) : rel;
+}
+function stripQuery(id) {
+	const queryIndex = id.indexOf("?");
+	return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
+function getHocString(from, name) {
+	return `${from}/${name}`;
+}
+function assertNever(value) {
+	throw new Error(`Unexpected value: ${value}`);
+}
+//#endregion
+//#region src/plugin/core/extract.ts
+function extractHocInfo(hocsSet, filename, source) {
+	const program = parseProgram(filename, source);
+	if (!program) return null;
+	const importDecls = [];
+	const trackedHocs = /* @__PURE__ */ new Map();
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration" || node.importKind === "type") continue;
+		importDecls.push(node);
+		for (const spec of node.specifiers) {
+			let importedName;
+			if (spec.type === "ImportSpecifier") {
+				if (spec.importKind === "type") continue;
+				importedName = spec.imported.type === "Literal" ? spec.imported.value : spec.imported.name;
+			} else if (spec.type === "ImportDefaultSpecifier") importedName = "default";
+			else continue;
+			if (hocsSet.has(getHocString(node.source.value, importedName))) trackedHocs.set(spec.local.name, {
+				from: node.source.value,
+				name: importedName
+			});
+		}
+	}
+	if (trackedHocs.size === 0) return null;
+	for (const node of program.body) {
+		if (node.type !== "ExportNamedDeclaration" || node.exportKind === "type" || node.declaration?.type !== "VariableDeclaration") continue;
+		for (const decl of node.declaration.declarations) {
+			if (decl.id.type !== "Identifier" || !decl.init || decl.init.type !== "CallExpression" || decl.init.callee.type !== "Identifier" || decl.init.arguments.length < 2) continue;
+			const hocEntry = trackedHocs.get(decl.init.callee.name);
+			if (!hocEntry) continue;
+			const [contentArg, loadingArg, errorArg] = decl.init.arguments;
+			const contentInfo = contentArg.type === "Identifier" ? {
+				kind: "identifier",
+				name: contentArg.name
+			} : {
+				kind: "inline",
+				argSource: source.slice(contentArg.start, contentArg.end),
+				argStart: contentArg.start,
+				argEnd: contentArg.end
+			};
+			return {
+				hocImportSource: hocEntry.from,
+				hocImportedName: hocEntry.name,
+				hocLocalName: decl.init.callee.name,
+				exportedName: decl.id.name,
+				hocExportStart: node.start,
+				content: contentInfo,
+				loading: {
+					argSource: source.slice(loadingArg.start, loadingArg.end),
+					argStart: loadingArg.start,
+					argEnd: loadingArg.end,
+					imports: filterNeededImports(importDecls, collectIdentifiers(loadingArg))
+				},
+				error: errorArg ? {
+					argSource: source.slice(errorArg.start, errorArg.end),
+					argStart: errorArg.start,
+					argEnd: errorArg.end,
+					imports: filterNeededImports(importDecls, collectIdentifiers(errorArg))
+				} : null
+			};
+		}
+	}
+	return null;
+}
+function extractReExports(filename, source) {
+	const named = /* @__PURE__ */ new Map();
+	const stars = [];
+	const program = parseProgram(filename, source);
+	if (!program) return {
+		named,
+		stars
+	};
+	const localImports = /* @__PURE__ */ new Map();
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration" || node.importKind === "type") continue;
+		for (const spec of node.specifiers) {
+			if (spec.type !== "ImportSpecifier" || spec.importKind === "type") continue;
+			const importedName = spec.imported.type === "Literal" ? spec.imported.value : spec.imported.name;
+			localImports.set(spec.local.name, {
+				source: node.source.value,
+				importedName
+			});
+		}
+	}
+	for (const node of program.body) {
+		if (node.type === "ExportAllDeclaration" && node.exportKind !== "type" && !node.exported) {
+			stars.push(node.source.value);
+			continue;
+		}
+		if (node.type !== "ExportNamedDeclaration" || node.exportKind === "type") continue;
+		if (node.source) {
+			const src = node.source.value;
+			for (const spec of node.specifiers) {
+				if (spec.exportKind === "type") continue;
+				const localName = spec.local.type === "Literal" ? spec.local.value : spec.local.name;
+				const exportedName = spec.exported.type === "Literal" ? spec.exported.value : spec.exported.name;
+				named.set(exportedName, {
+					source: src,
+					importedName: localName
+				});
+			}
+			continue;
+		}
+		if (node.declaration) continue;
+		for (const spec of node.specifiers) {
+			if (spec.exportKind === "type" || spec.local.type === "Literal") continue;
+			const target = localImports.get(spec.local.name);
+			if (!target) continue;
+			const exportedName = spec.exported.type === "Literal" ? spec.exported.value : spec.exported.name;
+			named.set(exportedName, target);
+		}
+	}
+	return {
+		named,
+		stars
+	};
+}
+const COMPANION_PROPS_RE = new RegExp(`\\.(${Object.values(COMPANION_TYPES).join("|")})\\b`);
+function extractUsages(filename, source) {
+	const result = [];
+	if (!COMPANION_PROPS_RE.test(source)) return result;
+	const program = parseProgram(filename, source);
+	if (!program) return result;
+	const trackedImports = /* @__PURE__ */ new Map();
+	const importLocalStarts = /* @__PURE__ */ new Set();
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		const declMeta = {
+			source: node.source.value,
+			namedSpecifiers: [],
+			start: node.start,
+			end: node.end
+		};
+		for (const spec of node.specifiers) {
+			if (spec.type !== "ImportSpecifier") continue;
+			const specMeta = {
+				localName: spec.local.name,
+				importedName: spec.imported.type === "Literal" ? spec.imported.value : spec.imported.name,
+				start: spec.start,
+				end: spec.end
+			};
+			declMeta.namedSpecifiers.push(specMeta);
+			trackedImports.set(spec.local.name, {
+				decl: declMeta,
+				spec: specMeta
+			});
+			importLocalStarts.add(spec.local.start);
+		}
+	}
+	if (trackedImports.size === 0) return result;
+	const usages = /* @__PURE__ */ new Map();
+	function ensureUsage(name) {
+		let usage = usages.get(name);
+		if (!usage) usages.set(name, usage = {
+			totalStarts: /* @__PURE__ */ new Set(),
+			accesses: []
+		});
+		return usage;
+	}
+	function trackIdentifier(name, start) {
+		if (trackedImports.has(name) && !importLocalStarts.has(start)) ensureUsage(name).totalStarts.add(start);
+	}
+	function trackCompanionAccess(localName, prop, exprStart, exprEnd) {
+		ensureUsage(localName).accesses.push({
+			prop,
+			start: exprStart,
+			end: exprEnd
+		});
+	}
+	new oxc_parser.Visitor({
+		Identifier(node) {
+			trackIdentifier(node.name, node.start);
+		},
+		JSXIdentifier(node) {
+			trackIdentifier(node.name, node.start);
+		},
+		MemberExpression(node) {
+			if (!node.computed && node.object.type === "Identifier" && trackedImports.has(node.object.name) && node.property.type === "Identifier" && isCompanionSuffix(node.property.name)) trackCompanionAccess(node.object.name, node.property.name, node.start, node.end);
+		},
+		JSXMemberExpression(node) {
+			if (node.object.type === "JSXIdentifier" && trackedImports.has(node.object.name) && isCompanionSuffix(node.property.name)) trackCompanionAccess(node.object.name, node.property.name, node.start, node.end);
+		}
+	}).visit(program);
+	for (const [localName, { accesses, totalStarts }] of usages) {
+		if (accesses.length === 0) continue;
+		const { decl, spec } = trackedImports.get(localName);
+		const hasOtherUsages = totalStarts.size > accesses.length;
+		result.push({
+			decl,
+			spec,
+			accesses,
+			hasOtherUsages
+		});
+	}
+	return result;
+}
+function collectIdentifiers(node) {
+	const result = /* @__PURE__ */ new Set();
+	walk(node, (current) => {
+		if (isOwnIdentifier(current) || isJSXIdentifier(current)) result.add(current.name);
+	});
+	return result;
+}
+function filterNeededImports(importDecls, identifiers) {
+	const result = [];
+	for (const decl of importDecls) {
+		if (decl.specifiers.length === 0) {
+			result.push(decl);
+			continue;
+		}
+		const specifiers = decl.specifiers.filter((spec) => identifiers.has(spec.local.name));
+		if (specifiers.length > 0) result.push({
+			...decl,
+			specifiers
+		});
+	}
+	return result;
+}
+function isOwnNode(node) {
+	return typeof node === "object" && node !== null && "type" in node && typeof node.type === "string";
+}
+function isOwnIdentifier(node) {
+	return node.type === "Identifier";
+}
+function isJSXIdentifier(node) {
+	return node.type === "JSXIdentifier";
+}
+function walk(node, visitor) {
+	if (!isOwnNode(node)) return;
+	visitor(node);
+	for (const value of Object.values(node)) if (Array.isArray(value)) for (const item of value) walk(item, visitor);
+	else walk(value, visitor);
+}
+function parseProgram(filename, source) {
+	const parsed = (0, oxc_parser.parseSync)(filename, source, {
+		sourceType: "module",
+		range: true
+	});
+	if (parsed.errors.some((error) => error.severity === "Error")) return null;
+	return parsed.program;
+}
+//#endregion
+//#region src/plugin/core/generate.ts
+function generateAuxModuleCode(exportedName, info, type) {
+	const suffix = COMPANION_TYPES[type];
+	return [
+		renderImports(info.imports),
+		"",
+		`export const ${exportedName}${suffix} = ${info.argSource};`,
+		""
+	].join("\n").trimStart();
+}
+function generateLazyModule(sourceFile, info, options = {}) {
+	const importSource = options.jsx?.importSource ?? "react";
+	const name = info.exportedName;
+	const cleanSourceFile = stripQuery(sourceFile);
+	const base = `./${node_path.default.basename(cleanSourceFile, node_path.default.extname(cleanSourceFile))}`;
+	const hocBinding = info.hocImportedName === "default" ? info.hocLocalName : info.hocImportedName;
+	const lines = [
+		`import {lazy} from '${importSource}';`,
+		"",
+		info.hocImportedName === "default" ? `import ${info.hocLocalName} from '${info.hocImportSource}';` : `import {${info.hocImportedName}} from '${info.hocImportSource}';`,
+		"",
+		`import {${name}Loading} from '${base}.Loading';`
+	];
+	if (info.error) lines.push(`import {${name}Error} from '${base}.Error';`);
+	lines.push("", `export const ${name}Lazy = ${hocBinding}(`, `    lazy(() => import('${base}').then((m) => ({default: m.${name}Content}))),`, `    ${name}Loading,`);
+	if (info.error) lines.push(`    ${name}Error,`);
+	lines.push(`);`, ``);
+	const code = lines.join("\n");
+	const filename = makeCompanionId("lazy", cleanSourceFile);
+	return {
+		code,
+		map: new magic_string.default(code).generateMap({
+			source: filename,
+			includeContent: true,
+			hires: false
+		}).toString()
+	};
+}
+function transformJsx(filename, code, options = {}) {
+	const result = (0, oxc_transform.transformSync)(filename, code, {
+		lang: "tsx",
+		jsx: options.jsx,
+		target: options.target,
+		sourcemap: true
+	});
+	if (result.errors.length > 0) {
+		const error = result.errors[0];
+		throw new Error(error.codeframe ?? error.message);
+	}
+	return {
+		code: result.code,
+		map: JSON.stringify(result.map)
+	};
+}
+function renderImport(decl) {
+	const parts = [];
+	const named = [];
+	for (const spec of decl.specifiers) if (spec.type === "ImportDefaultSpecifier") parts.push(spec.local.name);
+	else if (spec.type === "ImportNamespaceSpecifier") parts.push(`* as ${spec.local.name}`);
+	else {
+		const imported = spec.imported.type === "Literal" ? JSON.stringify(spec.imported.value) : spec.imported.name;
+		const renderedSpec = imported === spec.local.name ? spec.local.name : `${imported} as ${spec.local.name}`;
+		named.push(spec.importKind === "type" ? `type ${renderedSpec}` : renderedSpec);
+	}
+	if (named.length > 0) parts.push(`{${named.join(", ")}}`);
+	return `import ${decl.importKind === "type" ? "type " : ""}${parts.join(", ")} from '${decl.source.value}';`;
+}
+function renderImports(imports) {
+	return imports.map(renderImport).join("\n");
+}
+//#endregion
+//#region src/plugin/core/resolve.ts
+async function resolveSourceFile(ctx, sourceFile, importer) {
+	const nativeCtx = ctx.getNativeBuildContext?.();
+	const directory = node_path.default.dirname(importer);
+	if (nativeCtx?.framework === "webpack" || nativeCtx?.framework === "rspack") return resolveWithCompiler(nativeCtx.compiler, directory, sourceFile);
+	if (nativeCtx?.framework === "esbuild") {
+		const result = await nativeCtx.build.resolve(sourceFile, {
+			kind: "import-statement",
+			importer,
+			resolveDir: directory
+		});
+		return result.errors.length === 0 && result.path ? result.path : null;
+	}
+	if ("resolve" in ctx && typeof ctx.resolve === "function") {
+		const resolved = await ctx.resolve(sourceFile, importer, { skipSelf: true });
+		if (!resolved || resolved.external) return null;
+		return resolved.id;
+	}
+	return null;
+}
+function resolveWithCompiler(compiler, directory, request) {
+	return new Promise((resolve) => {
+		try {
+			compiler.resolverFactory.get("normal").resolve({}, directory, request, {}, (error, result) => {
+				resolve(!error && typeof result === "string" ? result : null);
+			});
+		} catch {
+			resolve(null);
+		}
+	});
+}
+//#endregion
+//#region src/plugin/core/transform.ts
+function transformDefinitionModule(s, filename, info) {
+	const name = info.exportedName;
+	const cleanFilename = stripQuery(filename);
+	const localSource = `./${node_path.default.basename(cleanFilename, node_path.default.extname(cleanFilename))}`;
+	const prependImports = [renderNamedImport(`${name}Loading`, `${name}Loading`, makeCompanionId("loading", localSource))];
+	if (info.error) prependImports.push(renderNamedImport(`${name}Error`, `${name}Error`, makeCompanionId("error", localSource)));
+	s.prepend(prependImports.join("\n") + "\n");
+	s.overwrite(info.loading.argStart, info.loading.argEnd, `${name}Loading`);
+	if (info.error) s.overwrite(info.error.argStart, info.error.argEnd, `${name}Error`);
+	if (info.content.kind === "identifier") s.append(`\nexport {${info.content.name} as ${name}Content};\n`);
+	else {
+		s.appendLeft(info.hocExportStart, `const ${name}Content = ${info.content.argSource};\n\n`);
+		s.overwrite(info.content.argStart, info.content.argEnd, `${name}Content`);
+		s.append(`\nexport {${name}Content};\n`);
+	}
+}
+function transformUsages(s, usages) {
+	for (const { usage } of usages) for (const access of usage.accesses) s.overwrite(access.start, access.end, `${usage.spec.localName}${access.prop}`);
+	const newImports = [];
+	for (const { usage, hocImportSource, hocExportedName } of usages) {
+		const propsUsed = new Set(usage.accesses.map((access) => access.prop));
+		for (const prop of propsUsed) newImports.push(renderNamedImport(`${usage.spec.localName}${prop}`, `${hocExportedName}${prop}`, makeCompanionId(COMPANION_TYPE_BY_SUFFIX[prop], hocImportSource)));
+	}
+	if (newImports.length > 0) s.prepend(newImports.join("\n") + "\n");
+	const localsByDecl = /* @__PURE__ */ new Map();
+	for (const { usage } of usages) {
+		if (usage.hasOtherUsages) continue;
+		let locals = localsByDecl.get(usage.decl);
+		if (!locals) localsByDecl.set(usage.decl, locals = /* @__PURE__ */ new Set());
+		locals.add(usage.spec.localName);
+	}
+	for (const [decl, locals] of localsByDecl) removeImportSpecifiers(s, decl, locals);
+}
+function removeImportSpecifiers(s, decl, localsToRemove) {
+	const kept = decl.namedSpecifiers.filter((spec) => !localsToRemove.has(spec.localName));
+	if (kept.length === 0) {
+		s.remove(decl.start, s.original[decl.end] === "\n" ? decl.end + 1 : decl.end);
+		return;
+	}
+	const firstSpec = decl.namedSpecifiers[0];
+	const lastSpec = decl.namedSpecifiers[decl.namedSpecifiers.length - 1];
+	const braceOpen = s.original.lastIndexOf("{", firstSpec.start);
+	const braceClose = s.original.indexOf("}", lastSpec.end);
+	if (braceOpen === -1 || braceClose === -1) return;
+	const keptText = kept.map((spec) => s.original.slice(spec.start, spec.end)).join(", ");
+	s.overwrite(braceOpen + 1, braceClose, keptText);
+}
+function renderNamedImport(local, imported, source) {
+	return `import {${local === imported ? imported : `${imported} as ${local}`}} from '${source}';`;
+}
+//#endregion
+//#region src/plugin/core/factory.ts
+const DEFAULT_HOCS = [
+	{
+		from: "@gravity-ui/data-source",
+		name: "withAsync"
+	},
+	{
+		from: "@gravity-ui/data-source",
+		name: "withAsyncBoundary"
+	},
+	{
+		from: "@gravity-ui/data-source",
+		name: "withQueryAsyncBoundary"
+	}
+];
+const DEFAULT_INCLUDE = /\.(tsx?|jsx?)$/;
+const VIRTUAL_EXCLUDE = new RegExp(`${VIRTUAL_PREFIX}|${encodeURIComponent(VIRTUAL_PREFIX)}`);
+const dataSourceLazyUnpluginFactory = (options = {}) => {
+	const hocPatterns = options.hocs ?? DEFAULT_HOCS;
+	const include = options.include ?? DEFAULT_INCLUDE;
+	const exclude = [VIRTUAL_EXCLUDE];
+	if (Array.isArray(options.exclude)) exclude.push(...options.exclude);
+	else if (options.exclude) exclude.push(options.exclude);
+	const hocsSet = new Set(hocPatterns.map((pattern) => getHocString(pattern.from, pattern.name)));
+	const hocsRegexp = new RegExp(Array.from(new Set(hocPatterns.map((pattern) => pattern.name))).map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"));
+	const hocInfoCache = /* @__PURE__ */ new Map();
+	const reExportsCache = /* @__PURE__ */ new Map();
+	const getHocInfo = (sourceFile, source) => {
+		const key = stripQuery(sourceFile);
+		const cachedInfo = hocInfoCache.get(key);
+		if (cachedInfo !== void 0) return cachedInfo;
+		const resolvedSource = source ?? node_fs.default.readFileSync(key, "utf-8");
+		const info = hocsRegexp.test(resolvedSource) ? extractHocInfo(hocsSet, key, resolvedSource) : null;
+		hocInfoCache.set(key, info);
+		return info;
+	};
+	const getReExports = (sourceFile, source) => {
+		const key = stripQuery(sourceFile);
+		const cachedReExports = reExportsCache.get(key);
+		if (cachedReExports) return cachedReExports;
+		const reExports = extractReExports(key, source ?? node_fs.default.readFileSync(key, "utf-8"));
+		reExportsCache.set(key, reExports);
+		return reExports;
+	};
+	const resolveHocSourceFile = async (ctx, file, importedName, visited = /* @__PURE__ */ new Set()) => {
+		const visitKey = `${file}\0${importedName}`;
+		if (visited.has(visitKey)) return null;
+		visited.add(visitKey);
+		const directInfo = getHocInfo(file);
+		if (directInfo && directInfo.exportedName === importedName) return {
+			file,
+			info: directInfo
+		};
+		const reExports = getReExports(file);
+		const named = reExports.named.get(importedName);
+		if (named) {
+			const resolved = await resolveSourceFile(ctx, named.source, file);
+			if (resolved) {
+				const next = await resolveHocSourceFile(ctx, resolved, named.importedName, visited);
+				if (next) return next;
+			}
+		}
+		for (const starSource of reExports.stars) {
+			const resolved = await resolveSourceFile(ctx, starSource, file);
+			if (!resolved) continue;
+			const next = await resolveHocSourceFile(ctx, resolved, importedName, visited);
+			if (next) return next;
+		}
+		return null;
+	};
+	const verifyUsages = async (ctx, usages, importerId) => {
+		return (await Promise.all(usages.map(async (usage) => {
+			const resolvedSourceFile = await resolveSourceFile(ctx, usage.decl.source, importerId);
+			if (!resolvedSourceFile) return null;
+			const target = await resolveHocSourceFile(ctx, resolvedSourceFile, usage.spec.importedName);
+			if (!target) return null;
+			return {
+				usage,
+				hocImportSource: toRelativeImportSource(importerId, target.file),
+				hocExportedName: target.info.exportedName
+			};
+		}))).filter((usage) => usage !== null);
+	};
+	return {
+		name: "data-source-lazy",
+		enforce: "pre",
+		async resolveId(id, importer) {
+			if (!importer) return null;
+			const companion = parseCompanionId(id);
+			const parsedImporter = parseVirtualId(importer);
+			const normalizedImporter = parsedImporter?.sourceFile ?? importer;
+			if (companion) {
+				if (await resolveSourceFile(this, id, normalizedImporter)) return null;
+				const resolvedSourceFile = await resolveSourceFile(this, companion.sourceFile, normalizedImporter);
+				return resolvedSourceFile && makeVirtualId(companion.type, resolvedSourceFile);
+			}
+			if (parsedImporter && isRelativeId(id)) return resolveSourceFile(this, id, parsedImporter.sourceFile);
+			return null;
+		},
+		load: {
+			filter: { id: new RegExp(VIRTUAL_PREFIX) },
+			async handler(id) {
+				const parsedId = parseVirtualId(id);
+				if (!parsedId) return null;
+				this.addWatchFile(parsedId.sourceFile);
+				const info = getHocInfo(parsedId.sourceFile);
+				if (!info) return null;
+				if (parsedId.type === "loading" || parsedId.type === "error") {
+					const auxInfo = info[parsedId.type];
+					if (!auxInfo) return null;
+					const filename = makeCompanionId(parsedId.type, parsedId.sourceFile);
+					const code = generateAuxModuleCode(info.exportedName, auxInfo, parsedId.type);
+					const usages = extractUsages(filename, code);
+					const verifiedUsages = await verifyUsages(this, usages, parsedId.sourceFile);
+					let resultCode = code;
+					if (verifiedUsages.length > 0) {
+						const s = new magic_string.default(code);
+						transformUsages(s, verifiedUsages);
+						resultCode = s.toString();
+					}
+					return transformJsx(filename, resultCode, options.generateOptions);
+				}
+				if (parsedId.type === "lazy") return generateLazyModule(parsedId.sourceFile, info, options.generateOptions);
+				return assertNever(parsedId.type);
+			}
+		},
+		transform: {
+			filter: { id: {
+				include,
+				exclude
+			} },
+			async handler(code, id) {
+				const info = getHocInfo(id, code);
+				const usages = extractUsages(id, code);
+				if (!info && usages.length === 0) return null;
+				const filteredUsages = info ? dropAccessesInsideHocArgs(info, usages) : usages;
+				const verifiedUsages = await verifyUsages(this, filteredUsages, id);
+				if (!info && verifiedUsages.length === 0) return null;
+				const s = new magic_string.default(code);
+				if (info) transformDefinitionModule(s, id, info);
+				if (verifiedUsages.length > 0) transformUsages(s, verifiedUsages);
+				if (!s.hasChanged()) return null;
+				return {
+					code: s.toString(),
+					map: s.generateMap({
+						source: id,
+						hires: true
+					}).toString()
+				};
+			}
+		},
+		watchChange(id) {
+			const key = stripQuery(id);
+			hocInfoCache.delete(key);
+			reExportsCache.delete(key);
+		}
+	};
+};
+function isInside(info, access) {
+	return info.argStart <= access.start && access.end <= info.argEnd;
+}
+function dropAccessesInsideHocArgs(info, usages) {
+	const result = [];
+	for (const usage of usages) {
+		const accesses = usage.accesses.filter((access) => !isInside(info.loading, access) && !(info.error && isInside(info.error, access)) && !(info.content.kind === "inline" && isInside(info.content, access)));
+		if (accesses.length === 0) continue;
+		if (accesses.length === usage.accesses.length) {
+			result.push(usage);
+			continue;
+		}
+		result.push({
+			...usage,
+			accesses
+		});
+	}
+	return result;
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_HOCS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_HOCS;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "dataSourceLazyUnpluginFactory", {
+	enumerable: true,
+	get: function() {
+		return dataSourceLazyUnpluginFactory;
+	}
+});