@gravity-ui/data-source 0.9.0 → 0.9.1-alpha.0

package/build/plugin/factory-2tSt4Rte.mjs

@@ -0,0 +1,513 @@
+import fs from "node:fs";
+import MagicString from "magic-string";
+import { Visitor, parseSync } from "oxc-parser";
+import path from "node:path";
+import { transformSync } from "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}:${sourceFile}`;
+}
+function parseVirtualId(id) {
+	if (id.indexOf("\0dsl-plugin") !== 0) return null;
+	const rest = id.slice(12);
+	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 ext = path.extname(sourceFile);
+	return `${ext ? sourceFile.slice(0, -ext.length) : sourceFile}.${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 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 !== 3) 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: {
+					argSource: source.slice(errorArg.start, errorArg.end),
+					argStart: errorArg.start,
+					argEnd: errorArg.end,
+					imports: filterNeededImports(importDecls, collectIdentifiers(errorArg))
+				}
+			};
+		}
+	}
+	return null;
+}
+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 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 = 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 generateAuxModule(sourceFile, info, type, options = {}) {
+	const auxInfo = info[type];
+	const name = info.exportedName;
+	const suffix = COMPANION_TYPES[type];
+	const cleanSourceFile = stripQuery(sourceFile);
+	const code = [
+		renderImports(auxInfo.imports),
+		"",
+		`export const ${name}${suffix} = ${auxInfo.argSource};`,
+		""
+	].join("\n").trimStart();
+	return transformJsx(makeCompanionId(type, cleanSourceFile), code, options);
+}
+function generateLazyModule(sourceFile, info, options = {}) {
+	const importSource = options.jsx?.importSource ?? "react";
+	const name = info.exportedName;
+	const cleanSourceFile = stripQuery(sourceFile);
+	const base = `./${path.basename(cleanSourceFile, path.extname(cleanSourceFile))}`;
+	const code = [
+		`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';`,
+		`import {${name}Error} from '${base}.Error';`,
+		``,
+		`export const ${name}Lazy = ${info.hocImportedName === "default" ? info.hocLocalName : info.hocImportedName}(`,
+		`    lazy(() => import('${base}').then((m) => ({default: m.${name}Content}))),`,
+		`    ${name}Loading,`,
+		`    ${name}Error,`,
+		`);`,
+		``
+	].join("\n");
+	const filename = makeCompanionId("lazy", cleanSourceFile);
+	return {
+		code,
+		map: new MagicString(code).generateMap({
+			source: filename,
+			includeContent: true,
+			hires: false
+		}).toString()
+	};
+}
+function transformJsx(filename, code, options) {
+	const result = 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 = path.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 = `./${path.basename(cleanFilename, path.extname(cleanFilename))}`;
+	s.prepend(`${renderNamedImport(`${name}Loading`, `${name}Loading`, makeCompanionId("loading", localSource))}\n${renderNamedImport(`${name}Error`, `${name}Error`, makeCompanionId("error", localSource))}\n`);
+	s.overwrite(info.loading.argStart, info.loading.argEnd, `${name}Loading`);
+	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 { spec, accesses } of usages) for (const access of accesses) s.overwrite(access.start, access.end, `${spec.localName}${access.prop}`);
+	const newImports = [];
+	for (const { decl, spec, accesses } of usages) {
+		const propsUsed = new Set(accesses.map((access) => access.prop));
+		for (const prop of propsUsed) newImports.push(renderNamedImport(`${spec.localName}${prop}`, `${spec.importedName}${prop}`, makeCompanionId(COMPANION_TYPE_BY_SUFFIX[prop], decl.source)));
+	}
+	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: "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 getHocInfo = (sourceFile, source) => {
+		const key = stripQuery(sourceFile);
+		const cachedInfo = hocInfoCache.get(key);
+		if (cachedInfo !== void 0) return cachedInfo;
+		const resolvedSource = source ?? fs.readFileSync(key, "utf-8");
+		const info = hocsRegexp.test(resolvedSource) ? extractHocInfo(hocsSet, key, resolvedSource) : null;
+		hocInfoCache.set(key, info);
+		return info;
+	};
+	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) },
+			handler(id) {
+				const parsedId = parseVirtualId(id);
+				if (!parsedId) return null;
+				this.addWatchFile(parsedId.sourceFile);
+				const info = getHocInfo(parsedId.sourceFile);
+				if (!info) return null;
+				switch (parsedId.type) {
+					case "loading":
+					case "error": return generateAuxModule(parsedId.sourceFile, info, parsedId.type, options.generateOptions);
+					case "lazy": return generateLazyModule(parsedId.sourceFile, info, options.generateOptions);
+					default: 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 verifiedUsages = (await Promise.all(usages.map(async (usage) => {
+					const resolvedSourceFile = await resolveSourceFile(this, usage.decl.source, id);
+					if (!resolvedSourceFile) return null;
+					const usageInfo = getHocInfo(resolvedSourceFile);
+					if (!usageInfo || usageInfo.exportedName !== usage.spec.importedName) return null;
+					return usage;
+				}))).filter((usage) => usage !== null);
+				if (!info && verifiedUsages.length === 0) return null;
+				const s = new MagicString(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) {
+			hocInfoCache.delete(stripQuery(id));
+		}
+	};
+};
+//#endregion
+export { dataSourceLazyUnpluginFactory as n, DEFAULT_HOCS as t };

package/build/plugin/index-mY40Sgl5.d.mts

@@ -0,0 +1,24 @@
+import { UnpluginFactory } from "unplugin";
+import { JsxOptions } from "oxc-transform";
+
+//#region src/plugin/core/generate.d.ts
+interface GenerateOptions {
+  jsx?: JsxOptions;
+  target?: string | string[];
+}
+//#endregion
+//#region src/plugin/core/factory.d.ts
+interface DataSourceLazyHocPattern {
+  from: string;
+  name: string;
+}
+interface DataSourceLazyPluginOptions {
+  hocs?: DataSourceLazyHocPattern[];
+  include?: RegExp | RegExp[];
+  exclude?: RegExp | RegExp[];
+  generateOptions?: GenerateOptions;
+}
+declare const DEFAULT_HOCS: DataSourceLazyPluginOptions['hocs'];
+declare const dataSourceLazyUnpluginFactory: UnpluginFactory<DataSourceLazyPluginOptions | undefined>;
+//#endregion
+export { dataSourceLazyUnpluginFactory as i, DataSourceLazyHocPattern as n, DataSourceLazyPluginOptions as r, DEFAULT_HOCS as t };

package/build/plugin/index.d.mts

@@ -0,0 +1,7 @@
+import { i as dataSourceLazyUnpluginFactory, n as DataSourceLazyHocPattern, r as DataSourceLazyPluginOptions, t as DEFAULT_HOCS } from "./index-mY40Sgl5.mjs";
+import * as _$unplugin from "unplugin";
+
+//#region src/plugin/index.d.ts
+declare const DataSourceLazyPlugin: _$unplugin.UnpluginInstance<DataSourceLazyPluginOptions | undefined, boolean>;
+//#endregion
+export { DEFAULT_HOCS, DataSourceLazyHocPattern, DataSourceLazyPlugin, DataSourceLazyPlugin as default, DataSourceLazyPluginOptions, dataSourceLazyUnpluginFactory };

package/build/plugin/index.mjs

@@ -0,0 +1,6 @@
+import { n as dataSourceLazyUnpluginFactory, t as DEFAULT_HOCS } from "./factory-2tSt4Rte.mjs";
+import { createUnplugin } from "unplugin";
+//#region src/plugin/index.ts
+const DataSourceLazyPlugin = /* @__PURE__ */ createUnplugin(dataSourceLazyUnpluginFactory);
+//#endregion
+export { DEFAULT_HOCS, DataSourceLazyPlugin, DataSourceLazyPlugin as default, dataSourceLazyUnpluginFactory };

package/build/plugin/rollup.d.mts

@@ -0,0 +1,6 @@
+import { r as DataSourceLazyPluginOptions } from "./index-mY40Sgl5.mjs";
+
+//#region src/plugin/rollup.d.ts
+declare const _default: (options?: DataSourceLazyPluginOptions | undefined) => any;
+//#endregion
+export { _default as default };

package/build/plugin/rollup.mjs

@@ -0,0 +1,6 @@
+import { n as dataSourceLazyUnpluginFactory } from "./factory-2tSt4Rte.mjs";
+import { createRollupPlugin } from "unplugin";
+//#region src/plugin/rollup.ts
+var rollup_default = createRollupPlugin(dataSourceLazyUnpluginFactory);
+//#endregion
+export { rollup_default as default };

package/build/plugin/rspack.d.mts

@@ -0,0 +1,7 @@
+import { r as DataSourceLazyPluginOptions } from "./index-mY40Sgl5.mjs";
+import * as _$unplugin from "unplugin";
+
+//#region src/plugin/rspack.d.ts
+declare const _default: (options?: DataSourceLazyPluginOptions | undefined) => _$unplugin.RspackPluginInstance;
+//#endregion
+export { _default as default };

package/build/plugin/rspack.mjs

@@ -0,0 +1,6 @@
+import { n as dataSourceLazyUnpluginFactory } from "./factory-2tSt4Rte.mjs";
+import { createRspackPlugin } from "unplugin";
+//#region src/plugin/rspack.ts
+var rspack_default = createRspackPlugin(dataSourceLazyUnpluginFactory);
+//#endregion
+export { rspack_default as default };

package/build/plugin/typings/client.d.ts

@@ -0,0 +1,11 @@
+import type {ComponentType} from 'react';
+
+declare module '@gravity-ui/data-source' {
+    interface AsyncBoundaryComponent<TProps extends object> {
+        Lazy: ComponentType<TProps>;
+    }
+
+    interface QueryAsyncBoundaryComponent<TProps extends object> {
+        Lazy: ComponentType<TProps>;
+    }
+}

package/build/plugin/vite.d.mts

@@ -0,0 +1,6 @@
+import { r as DataSourceLazyPluginOptions } from "./index-mY40Sgl5.mjs";
+
+//#region src/plugin/vite.d.ts
+declare const _default: (options?: DataSourceLazyPluginOptions | undefined) => any;
+//#endregion
+export { _default as default };

package/build/plugin/vite.mjs

@@ -0,0 +1,6 @@
+import { n as dataSourceLazyUnpluginFactory } from "./factory-2tSt4Rte.mjs";
+import { createVitePlugin } from "unplugin";
+//#region src/plugin/vite.ts
+var vite_default = createVitePlugin(dataSourceLazyUnpluginFactory);
+//#endregion
+export { vite_default as default };

package/build/plugin/webpack.d.mts

@@ -0,0 +1,7 @@
+import { r as DataSourceLazyPluginOptions } from "./index-mY40Sgl5.mjs";
+import * as _$webpack from "webpack";
+
+//#region src/plugin/webpack.d.ts
+declare const _default: (options?: DataSourceLazyPluginOptions | undefined) => _$webpack.WebpackPluginInstance;
+//#endregion
+export { _default as default };

package/build/plugin/webpack.mjs

@@ -0,0 +1,6 @@
+import { n as dataSourceLazyUnpluginFactory } from "./factory-2tSt4Rte.mjs";
+import { createWebpackPlugin } from "unplugin";
+//#region src/plugin/webpack.ts
+var webpack_default = createWebpackPlugin(dataSourceLazyUnpluginFactory);
+//#endregion
+export { webpack_default as default };