@yahoo/uds-v5-wip 0.0.1

package/dist/loader/dist/loader.js

@@ -0,0 +1,357 @@
+import { componentSlotClass } from "../../utils/dist/string-utils/componentClassName.js";
+import "../../utils/dist/index.js";
+import { loadManifest, loadTransformData } from "./loader/artifacts.js";
+import { isCompiledJsxCallee } from "./loader/babel-utils.js";
+import { canInlineSimpleLoweredComponent, resolveLoweredCreateComponentData } from "./loader/create-component-data.js";
+import { applySlotMotionToElement, clearHoistedMotionStates, componentHasExitMotion, getCustomSlotMotion, getHoistedMotionStates, handleMotionOnElement, wrapCustomComponentWithAnimatePresence, wrapParentConditionalWithAnimatePresence } from "./loader/motion-transform.js";
+import { findClassesParamName, findSlotFromClassNameAttr, findSlotFromPropsSpreadAttr, findSlotPropsParamName, handleCompiledJsxDataAttrs, injectInternalUdsProps } from "./loader/data-attr-transform.js";
+import { buildInlineSimpleLoweredCreateComponentRenderFn, buildInlineSimplePrimitiveCreateComponentRenderFn, buildLoweredCreateComponentConfigExpression, extractOwnPropKeys, inferCreateComponentNameFromAssignment, isCreateComponentRenderFnNode, remapOnPressToOnClickInJsxAttributes } from "./loader/create-component-lowering.js";
+import { createStyleTransformRuntime } from "./loader/style-transform.js";
+import * as t from "@babel/types";
+import path from "node:path";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+import { parse } from "@babel/parser";
+//#region ../loader/dist/loader.js
+const traverse = _traverse.default ?? _traverse;
+const generate = _generate.default ?? _generate;
+/** Build a custom component set from the manifest (used for motion transform). */
+function getCustomComponents(manifest) {
+	if (!manifest) return null;
+	const custom = /* @__PURE__ */ new Set();
+	for (const [name, entry] of Object.entries(manifest.components)) if (entry.type === "custom") custom.add(name);
+	return custom.size > 0 ? custom : null;
+}
+function isUdsImportSource(importSource) {
+	return importSource.startsWith("uds/") || importSource.startsWith("@uds/") || importSource === "uds";
+}
+function isUdsComponentReference(nodePath, componentName, allUdsComponents, udsImportedNames, createComponentDefinedNames, customComponents) {
+	if (!allUdsComponents.has(componentName)) return false;
+	const binding = nodePath.scope?.getBinding?.(componentName);
+	if (!binding?.path) return udsImportedNames.has(componentName) || createComponentDefinedNames.has(componentName);
+	const bindingNode = binding.path.node;
+	if (bindingNode?.type === "ImportSpecifier" || bindingNode?.type === "ImportDefaultSpecifier" || bindingNode?.type === "ImportNamespaceSpecifier") {
+		const parentNode = binding.path.parent;
+		if (!t.isImportDeclaration(parentNode)) return false;
+		return isUdsImportSource(parentNode.source.value) || customComponents?.has(componentName) === true;
+	}
+	return createComponentDefinedNames.has(componentName);
+}
+const transformLoader = function(source) {
+	const loaderContext = this ?? void 0;
+	if (!loaderContext?.getOptions) return source;
+	const { manifestPath, isDev, skipWatchDependencies } = loaderContext.getOptions();
+	const transformDataPath = path.join(path.dirname(manifestPath), "motion-transform-data.json");
+	const projectRoot = path.dirname(path.dirname(manifestPath));
+	const resourcePath = loaderContext.resourcePath ?? "";
+	if (resourcePath.includes(".uds/")) return source;
+	if (!skipWatchDependencies) {
+		loaderContext.addDependency?.(manifestPath);
+		loaderContext.addDependency?.(transformDataPath);
+	}
+	const manifest = loadManifest(manifestPath, isDev);
+	const transformData = loadTransformData(transformDataPath, isDev);
+	const styleRuntime = createStyleTransformRuntime(transformData, manifest);
+	const allUdsComponents = styleRuntime.allComponents;
+	const primitiveUdsComponents = styleRuntime.primitiveComponents;
+	const componentTagPatterns = styleRuntime.componentTagPatterns;
+	const hasAnyComponent = source.includes("from 'uds/") || source.includes("from \"@uds/") || source.includes("from 'uds'") || source.includes("from \"uds/") || source.includes("from '@uds/") || source.includes("from \"uds\"") || componentTagPatterns.length > 0 && componentTagPatterns.some((pattern) => source.includes(pattern));
+	const hasCreateComponent = source.includes("createComponent") || source.includes("createComponentStyler");
+	if (!hasAnyComponent && !hasCreateComponent) return source;
+	const customComponents = getCustomComponents(manifest);
+	const isTS = resourcePath?.endsWith(".ts") || resourcePath?.endsWith(".tsx");
+	const isJSX = resourcePath?.endsWith(".tsx") || resourcePath?.endsWith(".jsx");
+	const parserPlugins = [];
+	if (isJSX || !isTS) parserPlugins.push("jsx");
+	if (isTS) parserPlugins.push("typescript");
+	let ast;
+	try {
+		ast = parse(source, {
+			sourceType: "module",
+			plugins: parserPlugins
+		});
+	} catch {
+		return source;
+	}
+	let transformed = false;
+	const importsToAdd = /* @__PURE__ */ new Map();
+	let hasMotionImport = false;
+	let needsMotionImport = false;
+	let hasAnimatePresenceImport = false;
+	let needsAnimatePresenceImport = false;
+	let needsResolveMotionStateImport = false;
+	let needsProcessStylePropsImport = false;
+	clearHoistedMotionStates();
+	const stylerToComponent = /* @__PURE__ */ new Map();
+	const classesVarToComponent = /* @__PURE__ */ new Map();
+	const slotPropsVarToComponent = /* @__PURE__ */ new Map();
+	const udsImportedNames = /* @__PURE__ */ new Set();
+	const createComponentImportNames = /* @__PURE__ */ new Set();
+	const createVariantsImportNames = /* @__PURE__ */ new Set();
+	const createVariantsClassMaps = /* @__PURE__ */ new Map();
+	const hoistedVariantClassMapNames = /* @__PURE__ */ new Map();
+	const hoistedVariantClassMaps = /* @__PURE__ */ new Map();
+	const createComponentDefinedNames = /* @__PURE__ */ new Set();
+	let needsCreateComponentImportCleanup = false;
+	traverse(ast, {
+		JSXOpeningElement(nodePath) {
+			const jsxName = nodePath.node.name;
+			const jsxTagName = jsxName?.type === "JSXIdentifier" ? jsxName.name : void 0;
+			if (jsxTagName && !allUdsComponents.has(jsxTagName) && udsImportedNames.has(jsxTagName)) {
+				allUdsComponents.add(jsxTagName);
+				if (!primitiveUdsComponents.has(jsxTagName)) {
+					const manifestEntry = manifest?.components[jsxTagName];
+					if (manifestEntry?.type === "primitive" && manifestEntry.element || transformData?.primitiveElementMap?.[jsxTagName]) primitiveUdsComponents.add(jsxTagName);
+				}
+			}
+			const isUdsJsxTag = jsxTagName && isUdsComponentReference(nodePath, jsxTagName, allUdsComponents, udsImportedNames, createComponentDefinedNames, customComponents);
+			if (isDev && jsxTagName && isUdsJsxTag) {
+				injectInternalUdsProps(nodePath, resourcePath, projectRoot, {
+					componentName: jsxTagName,
+					slotName: "root"
+				});
+				transformed = true;
+			}
+			if (jsxTagName && isUdsJsxTag && remapOnPressToOnClickInJsxAttributes(nodePath.node.attributes)) transformed = true;
+			let motionTransformed = false;
+			if (isUdsJsxTag && handleMotionOnElement(nodePath, manifest, customComponents, primitiveUdsComponents, importsToAdd)) {
+				transformed = true;
+				motionTransformed = true;
+			}
+			if (jsxTagName && customComponents?.has(jsxTagName) && componentHasExitMotion(manifest, jsxTagName)) {
+				if (wrapCustomComponentWithAnimatePresence(nodePath)) {
+					needsAnimatePresenceImport = true;
+					transformed = true;
+				}
+			}
+			if (isUdsJsxTag && styleRuntime.transformUdsComponentStyleProps(nodePath, createVariantsClassMaps, hoistedVariantClassMapNames, hoistedVariantClassMaps)) transformed = true;
+			if (!motionTransformed && jsxTagName && isUdsJsxTag && primitiveUdsComponents.has(jsxTagName)) {
+				const baseElement = (manifest?.components[jsxTagName])?.element ?? transformData?.primitiveElementMap?.[jsxTagName];
+				if (baseElement) {
+					let resolvedElement = baseElement;
+					const asAttrIndex = nodePath.node.attributes.findIndex((attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "as");
+					if (asAttrIndex >= 0) {
+						const asAttr = nodePath.node.attributes[asAttrIndex];
+						if (t.isStringLiteral(asAttr.value)) {
+							resolvedElement = asAttr.value.value;
+							nodePath.node.attributes.splice(asAttrIndex, 1);
+						} else if (t.isJSXExpressionContainer(asAttr.value) && t.isStringLiteral(asAttr.value.expression)) {
+							resolvedElement = asAttr.value.expression.value;
+							nodePath.node.attributes.splice(asAttrIndex, 1);
+						}
+					}
+					const slotClassName = transformData?.componentClassData?.[jsxTagName]?.slotClassNames?.root ?? componentSlotClass(jsxTagName, "root");
+					nodePath.node.name = t.jsxIdentifier(resolvedElement);
+					const existingClassAttr = nodePath.node.attributes.find((attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "className");
+					if (existingClassAttr && t.isJSXAttribute(existingClassAttr)) {
+						if (t.isStringLiteral(existingClassAttr.value)) existingClassAttr.value = t.stringLiteral(`${slotClassName} ${existingClassAttr.value.value}`);
+						else if (t.isJSXExpressionContainer(existingClassAttr.value) && !t.isJSXEmptyExpression(existingClassAttr.value.expression)) if (t.isStringLiteral(existingClassAttr.value.expression)) existingClassAttr.value = t.jsxExpressionContainer(t.stringLiteral(`${slotClassName} ${existingClassAttr.value.expression.value}`));
+						else existingClassAttr.value = t.jsxExpressionContainer(t.templateLiteral([t.templateElement({
+							raw: `${slotClassName} `,
+							cooked: `${slotClassName} `
+						}, false), t.templateElement({
+							raw: "",
+							cooked: ""
+						}, true)], [existingClassAttr.value.expression]));
+					} else nodePath.node.attributes.push(t.jsxAttribute(t.jsxIdentifier("className"), t.stringLiteral(slotClassName)));
+					const parent = nodePath.parent;
+					if (parent?.type === "JSXElement" && parent.closingElement?.name?.type === "JSXIdentifier") parent.closingElement.name = t.jsxIdentifier(resolvedElement);
+					transformed = true;
+				}
+			}
+			const classNameSlotInfo = findSlotFromClassNameAttr(nodePath.node.attributes, classesVarToComponent, stylerToComponent, slotPropsVarToComponent);
+			const slotInfo = findSlotFromPropsSpreadAttr(nodePath.node.attributes, slotPropsVarToComponent) ?? classNameSlotInfo;
+			if (!slotInfo) return;
+			const slotMotion = getCustomSlotMotion(manifest, slotInfo);
+			if (slotMotion) {
+				const motionResult = applySlotMotionToElement(nodePath, slotMotion);
+				if (motionResult.transformed) {
+					transformed = true;
+					needsMotionImport = true;
+				}
+				if (motionResult.needsResolveMotionStateImport) needsResolveMotionStateImport = true;
+				if (motionResult.transformed && slotMotion.exit) {
+					if (wrapParentConditionalWithAnimatePresence(nodePath)) needsAnimatePresenceImport = true;
+				}
+			}
+			if (nodePath.node.attributes.some((attr) => attr.type === "JSXAttribute" && attr.name?.name === "data-uds-slot")) return;
+			nodePath.node.attributes.push(t.jsxAttribute(t.jsxIdentifier("data-uds-slot"), t.stringLiteral(slotInfo.slotName)), t.jsxAttribute(t.jsxIdentifier("data-uds-component"), t.stringLiteral(slotInfo.componentName)));
+			transformed = true;
+		},
+		ImportDeclaration(nodePath) {
+			const importSource = nodePath.node.source?.value;
+			if (!importSource) return;
+			if (importSource === "motion/react") {
+				for (const specifier of nodePath.node.specifiers) if (specifier.type === "ImportSpecifier" && specifier.imported?.type === "Identifier") {
+					if (specifier.imported.name === "motion") hasMotionImport = true;
+					if (specifier.imported.name === "AnimatePresence") hasAnimatePresenceImport = true;
+				}
+			}
+			if (!isUdsImportSource(importSource)) return;
+			for (const specifier of nodePath.node.specifiers) {
+				const localName = specifier.local?.name;
+				if (localName) udsImportedNames.add(localName);
+			}
+			for (const specifier of nodePath.node.specifiers) {
+				if (specifier.type !== "ImportSpecifier") continue;
+				const importedName = specifier.imported?.type === "Identifier" ? specifier.imported.name : specifier.imported?.value;
+				if (!importedName) continue;
+				const match = importedName.match(/^get(\w+)Styles$/);
+				if (match) {
+					const localName = specifier.local?.name ?? importedName;
+					stylerToComponent.set(localName, match[1]);
+				}
+				if (importedName === "createVariants") {
+					const localName = specifier.local?.name ?? importedName;
+					createVariantsImportNames.add(localName);
+					continue;
+				}
+				if (importedName === "createComponent") {
+					const localName = specifier.local?.name ?? importedName;
+					createComponentImportNames.add(localName);
+				}
+			}
+		},
+		VariableDeclarator(nodePath) {
+			const init = nodePath.node.init;
+			if (!init) return;
+			const id = nodePath.node.id;
+			if (init.type === "CallExpression" && init.callee?.type === "Identifier" && createVariantsImportNames.has(init.callee.name) && id?.type === "Identifier") {
+				const variantClassMap = styleRuntime.extractVariantClassMapFromCreateVariantsCall(init);
+				if (variantClassMap) createVariantsClassMaps.set(id.name, variantClassMap);
+				return;
+			}
+			if (init.type === "CallExpression" && init.callee?.type === "Identifier" && init.callee.name === "createComponentStyler" && init.arguments[0]?.type === "StringLiteral" && id?.type === "Identifier") {
+				stylerToComponent.set(id.name, init.arguments[0].value);
+				return;
+			}
+			if (init.type === "CallExpression" && init.callee?.type === "Identifier" && id?.type === "Identifier") {
+				const componentName = stylerToComponent.get(init.callee.name);
+				if (componentName) classesVarToComponent.set(id.name, componentName);
+				return;
+			}
+			if (init.type === "CallExpression" && init.callee?.type === "MemberExpression" && init.callee.property?.name === "resolve" && init.callee.object?.type === "Identifier" && id?.type === "ObjectPattern") {
+				const componentName = stylerToComponent.get(init.callee.object.name);
+				if (componentName) {
+					for (const prop of id.properties) if (prop.type === "ObjectProperty" && prop.key?.type === "Identifier" && prop.key.name === "classes") {
+						const valueName = prop.value?.type === "Identifier" ? prop.value.name : "classes";
+						classesVarToComponent.set(valueName, componentName);
+						break;
+					}
+				}
+			}
+		},
+		CallExpression(nodePath) {
+			const callee = nodePath.node.callee;
+			if (callee.type !== "Identifier") return;
+			if (isCompiledJsxCallee(callee)) {
+				const firstArg = nodePath.node.arguments[0];
+				if (t.isIdentifier(firstArg) && isUdsComponentReference(nodePath, firstArg.name, allUdsComponents, udsImportedNames, createComponentDefinedNames, customComponents) && styleRuntime.transformCompiledJsxStyleProps(nodePath.node, hoistedVariantClassMapNames, hoistedVariantClassMaps)) transformed = true;
+				const compiledResult = handleCompiledJsxDataAttrs(nodePath.node, classesVarToComponent, stylerToComponent, slotPropsVarToComponent, manifest);
+				if (compiledResult.transformed) transformed = true;
+				if (compiledResult.needsMotionImport) needsMotionImport = true;
+				if (compiledResult.needsResolveMotionStateImport) needsResolveMotionStateImport = true;
+				return;
+			}
+			const isCreateComponentCall = createComponentImportNames.has(callee.name) || createComponentImportNames.size === 0 && callee.name === "createComponent";
+			if (!isCreateComponentCall) return;
+			const args = nodePath.node.arguments;
+			const componentName = inferCreateComponentNameFromAssignment(nodePath);
+			if (!componentName) return;
+			createComponentDefinedNames.add(componentName);
+			let renderFn = null;
+			if (isCreateComponentCall) {
+				if (args.length >= 2 && args[0]?.type === "StringLiteral" && isCreateComponentRenderFnNode(args[1])) throw nodePath.buildCodeFrameError("createComponent(\"Name\", renderFn) is no longer supported. Use createComponent(renderFn).");
+				const isPrimitiveCreateComponentCall = args.length === 1 && t.isStringLiteral(args[0]);
+				if (!(args.length === 1 && isCreateComponentRenderFnNode(args[0])) && !isPrimitiveCreateComponentCall) return;
+				if (isCreateComponentRenderFnNode(args[0])) renderFn = args[0];
+			}
+			if (renderFn) {
+				const classesParam = findClassesParamName(renderFn);
+				if (classesParam) classesVarToComponent.set(classesParam, componentName);
+				const slotPropsParam = findSlotPropsParamName(renderFn);
+				if (slotPropsParam) slotPropsVarToComponent.set(slotPropsParam, componentName);
+			}
+			const loweredData = resolveLoweredCreateComponentData(componentName, renderFn ? extractOwnPropKeys(renderFn) : [], manifest, transformData);
+			if (args.length === 1 && t.isStringLiteral(args[0])) {
+				loweredData.rootElement = args[0].value;
+				if (canInlineSimpleLoweredComponent(loweredData)) {
+					const primitiveResult = buildInlineSimplePrimitiveCreateComponentRenderFn(loweredData);
+					nodePath.replaceWith(primitiveResult.expression);
+					if (primitiveResult.needsProcessStylePropsImport) needsProcessStylePropsImport = true;
+					needsCreateComponentImportCleanup = true;
+					transformed = true;
+					return;
+				}
+				nodePath.replaceWith(t.callExpression(t.cloneNode(callee), [buildLoweredCreateComponentConfigExpression(loweredData), t.cloneNode(args[0], true)]));
+				transformed = true;
+				return;
+			}
+			if (canInlineSimpleLoweredComponent(loweredData)) {
+				const inlineResult = buildInlineSimpleLoweredCreateComponentRenderFn(loweredData, renderFn);
+				nodePath.replaceWith(inlineResult.expression);
+				if (inlineResult.needsMotionImport) needsMotionImport = true;
+				if (inlineResult.needsAnimatePresenceImport) needsAnimatePresenceImport = true;
+				if (inlineResult.needsResolveMotionStateImport) needsResolveMotionStateImport = true;
+				needsCreateComponentImportCleanup = true;
+				transformed = true;
+				return;
+			}
+			if (!renderFn) return;
+			nodePath.replaceWith(t.callExpression(t.cloneNode(callee), [buildLoweredCreateComponentConfigExpression(loweredData), t.cloneNode(renderFn, true)]));
+			transformed = true;
+		}
+	});
+	if (needsCreateComponentImportCleanup) traverse(ast, { ImportDeclaration(nodePath) {
+		const importSource = nodePath.node.source?.value;
+		if (!importSource) return;
+		if (!isUdsImportSource(importSource)) return;
+		const nextSpecifiers = nodePath.node.specifiers.filter((specifier) => {
+			if (specifier.type !== "ImportSpecifier") return true;
+			const importedName = specifier.imported?.type === "Identifier" ? specifier.imported.name : specifier.imported?.value;
+			if (importedName !== "createComponent") return true;
+			const localName = specifier.local?.name ?? importedName;
+			nodePath.scope.crawl();
+			const binding = nodePath.scope.getBinding(localName);
+			return Boolean(binding?.referenced);
+		});
+		if (nextSpecifiers.length === nodePath.node.specifiers.length) return;
+		if (nextSpecifiers.length === 0) {
+			nodePath.remove();
+			return;
+		}
+		nodePath.node.specifiers = nextSpecifiers;
+	} });
+	if (!transformed) return source;
+	const sourceDir = path.dirname(resourcePath || projectRoot);
+	for (const [componentName, importPath] of importsToAdd) {
+		const absoluteImport = path.resolve(projectRoot, importPath);
+		let resolvedPath = path.relative(sourceDir, absoluteImport);
+		if (!resolvedPath.startsWith(".")) resolvedPath = `./${resolvedPath}`;
+		ast.program.body.unshift(t.importDeclaration([t.importSpecifier(t.identifier(componentName), t.identifier(componentName))], t.stringLiteral(resolvedPath)));
+	}
+	const motionImportSpecifiers = [];
+	if (needsMotionImport && !hasMotionImport) motionImportSpecifiers.push(t.importSpecifier(t.identifier("motion"), t.identifier("motion")));
+	if (needsAnimatePresenceImport && !hasAnimatePresenceImport) motionImportSpecifiers.push(t.importSpecifier(t.identifier("AnimatePresence"), t.identifier("AnimatePresence")));
+	if (motionImportSpecifiers.length > 0) ast.program.body.unshift(t.importDeclaration(motionImportSpecifiers, t.stringLiteral("motion/react")));
+	if (needsProcessStylePropsImport) {
+		if (!ast.program.body.some((node) => t.isImportDeclaration(node) && node.specifiers.some((s) => t.isImportSpecifier(s) && (t.isIdentifier(s.imported) && s.imported.name === "processStyleProps" || t.isStringLiteral(s.imported) && s.imported.value === "processStyleProps")))) ast.program.body.unshift(t.importDeclaration([t.importSpecifier(t.identifier("processStyleProps"), t.identifier("processStyleProps"))], t.stringLiteral("@uds/core")));
+	}
+	if (needsResolveMotionStateImport) ast.program.body.unshift(t.importDeclaration([t.importSpecifier(t.identifier("__rms"), t.identifier("resolveMotionState"))], t.stringLiteral("@uds/core")));
+	const motionStatesMap = getHoistedMotionStates();
+	if (motionStatesMap.size > 0) for (const [varName, statesConfig] of motionStatesMap) ast.program.body.unshift(t.variableDeclaration("const", [t.variableDeclarator(t.identifier(varName), t.valueToNode(statesConfig))]));
+	if (hoistedVariantClassMaps.size > 0) {
+		const declarations = [];
+		for (const [lookupName, classMap] of hoistedVariantClassMaps) declarations.push(t.variableDeclaration("const", [t.variableDeclarator(t.identifier(lookupName), t.objectExpression(Object.entries(classMap).map(([variantName, className]) => t.objectProperty(t.stringLiteral(variantName), t.stringLiteral(className)))))]));
+		const firstNonImportIndex = ast.program.body.findIndex((node) => node.type !== "ImportDeclaration");
+		if (firstNonImportIndex === -1) ast.program.body.push(...declarations);
+		else ast.program.body.splice(firstNonImportIndex, 0, ...declarations);
+	}
+	return generate(ast, {
+		retainLines: true,
+		sourceMaps: false
+	}).code;
+};
+const normal = transformLoader;
+//#endregion
+export { normal, transformLoader };

package/dist/loader/dist/next.d.ts

@@ -0,0 +1,17 @@
+import { NextConfig } from "next";
+
+//#region ../loader/dist/next.d.ts
+//#region src/next.d.ts
+interface WithUdsOptions {
+  /** Output directory for generated files (default: '.uds') */
+  outputDir?: string;
+  /** Skip addDependency calls to prevent webpack from watching .uds/ artifacts.
+   *  Use this when the app has its own reload mechanism (e.g., Studio WebSocket). */
+  skipWatchDependencies?: boolean;
+}
+type NextConfigFn = (phase: string, ctx: {
+  defaultConfig: NextConfig;
+}) => NextConfig | Promise<NextConfig>;
+declare function withUds(nextConfigOrFn: NextConfig | NextConfigFn, options?: WithUdsOptions): NextConfig | NextConfigFn; //#endregion
+//#endregion
+export { WithUdsOptions, withUds };

package/dist/loader/dist/next.js

@@ -0,0 +1,77 @@
+import { __require } from "./_virtual/_rolldown/runtime.js";
+import path from "node:path";
+//#region ../loader/dist/next.js
+function resolveLoaderPath() {
+	return __require.resolve("@uds/loader/loader");
+}
+function applyUds(nextConfig, options) {
+	const outputDir = options?.outputDir ?? ".uds";
+	const skipWatch = options?.skipWatchDependencies ?? false;
+	const manifestPath = path.resolve(process.cwd(), outputDir, "meta-loader.json");
+	const loaderPath = resolveLoaderPath();
+	const turbopack = nextConfig.turbopack ?? {};
+	const existingRules = turbopack.rules ?? {};
+	const udsLoader = {
+		loader: loaderPath,
+		options: {
+			manifestPath,
+			isDev: true,
+			skipWatchDependencies: skipWatch
+		}
+	};
+	const udsRules = {};
+	for (const ext of [
+		"tsx",
+		"ts",
+		"js"
+	]) {
+		const key = `*.${ext}`;
+		const udsKey = `**/*.${ext}`;
+		if (existingRules[key]) udsRules[udsKey] = { loaders: [udsLoader] };
+		else udsRules[key] = { loaders: [udsLoader] };
+	}
+	return {
+		...nextConfig,
+		turbopack: {
+			...turbopack,
+			rules: {
+				...existingRules,
+				...udsRules
+			}
+		},
+		webpack(config, webpackOptions) {
+			config.module?.rules?.push({
+				test: /\.(tsx|ts|js)$/,
+				use: [{
+					loader: loaderPath,
+					options: {
+						manifestPath,
+						isDev: webpackOptions.dev,
+						skipWatchDependencies: skipWatch
+					}
+				}]
+			});
+			if (skipWatch) {
+				const existing = config.watchOptions?.ignored;
+				config.watchOptions = {
+					...config.watchOptions,
+					ignored: [
+						...Array.isArray(existing) ? existing : existing ? [existing] : [],
+						"**/.uds/**",
+						"**/uds.config.ts"
+					]
+				};
+			}
+			if (typeof nextConfig.webpack === "function") return nextConfig.webpack(config, webpackOptions);
+			return config;
+		}
+	};
+}
+function withUds(nextConfigOrFn, options) {
+	if (typeof nextConfigOrFn === "function") return async (phase, ctx) => {
+		return applyUds(await nextConfigOrFn(phase, ctx), options);
+	};
+	return applyUds(nextConfigOrFn, options);
+}
+//#endregion
+export { withUds };

package/dist/loader/dist/node_modules/react/cjs/react-jsx-runtime.development.js

@@ -0,0 +1,203 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_react } from "../index.js";
+//#region ../loader/dist/node_modules/react/cjs/react-jsx-runtime.development.js
+/**
+* @license React
+* react-jsx-runtime.development.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	(function() {
+		function getComponentNameFromType(type) {
+			if (null == type) return null;
+			if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+			if ("string" === typeof type) return type;
+			switch (type) {
+				case REACT_FRAGMENT_TYPE: return "Fragment";
+				case REACT_PROFILER_TYPE: return "Profiler";
+				case REACT_STRICT_MODE_TYPE: return "StrictMode";
+				case REACT_SUSPENSE_TYPE: return "Suspense";
+				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
+				case REACT_ACTIVITY_TYPE: return "Activity";
+			}
+			if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+				case REACT_PORTAL_TYPE: return "Portal";
+				case REACT_CONTEXT_TYPE: return type.displayName || "Context";
+				case REACT_CONSUMER_TYPE: return (type._context.displayName || "Context") + ".Consumer";
+				case REACT_FORWARD_REF_TYPE:
+					var innerType = type.render;
+					type = type.displayName;
+					type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+					return type;
+				case REACT_MEMO_TYPE: return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+				case REACT_LAZY_TYPE:
+					innerType = type._payload;
+					type = type._init;
+					try {
+						return getComponentNameFromType(type(innerType));
+					} catch (x) {}
+			}
+			return null;
+		}
+		function testStringCoercion(value) {
+			return "" + value;
+		}
+		function checkKeyStringCoercion(value) {
+			try {
+				testStringCoercion(value);
+				var JSCompiler_inline_result = !1;
+			} catch (e) {
+				JSCompiler_inline_result = !0;
+			}
+			if (JSCompiler_inline_result) {
+				JSCompiler_inline_result = console;
+				var JSCompiler_temp_const = JSCompiler_inline_result.error;
+				var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+				JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+				return testStringCoercion(value);
+			}
+		}
+		function getTaskName(type) {
+			if (type === REACT_FRAGMENT_TYPE) return "<>";
+			if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+			try {
+				var name = getComponentNameFromType(type);
+				return name ? "<" + name + ">" : "<...>";
+			} catch (x) {
+				return "<...>";
+			}
+		}
+		function getOwner() {
+			var dispatcher = ReactSharedInternals.A;
+			return null === dispatcher ? null : dispatcher.getOwner();
+		}
+		function UnknownOwner() {
+			return Error("react-stack-top-frame");
+		}
+		function hasValidKey(config) {
+			if (hasOwnProperty.call(config, "key")) {
+				var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+				if (getter && getter.isReactWarning) return !1;
+			}
+			return void 0 !== config.key;
+		}
+		function defineKeyPropWarningGetter(props, displayName) {
+			function warnAboutAccessingKey() {
+				specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+			}
+			warnAboutAccessingKey.isReactWarning = !0;
+			Object.defineProperty(props, "key", {
+				get: warnAboutAccessingKey,
+				configurable: !0
+			});
+		}
+		function elementRefGetterWithDeprecationWarning() {
+			var componentName = getComponentNameFromType(this.type);
+			didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+			componentName = this.props.ref;
+			return void 0 !== componentName ? componentName : null;
+		}
+		function ReactElement(type, key, props, owner, debugStack, debugTask) {
+			var refProp = props.ref;
+			type = {
+				$$typeof: REACT_ELEMENT_TYPE,
+				type,
+				key,
+				props,
+				_owner: owner
+			};
+			null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				get: elementRefGetterWithDeprecationWarning
+			}) : Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				value: null
+			});
+			type._store = {};
+			Object.defineProperty(type._store, "validated", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: 0
+			});
+			Object.defineProperty(type, "_debugInfo", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: null
+			});
+			Object.defineProperty(type, "_debugStack", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugStack
+			});
+			Object.defineProperty(type, "_debugTask", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugTask
+			});
+			Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+			return type;
+		}
+		function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+			var children = config.children;
+			if (void 0 !== children) if (isStaticChildren) if (isArrayImpl(children)) {
+				for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++) validateChildKeys(children[isStaticChildren]);
+				Object.freeze && Object.freeze(children);
+			} else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+			else validateChildKeys(children);
+			if (hasOwnProperty.call(config, "key")) {
+				children = getComponentNameFromType(type);
+				var keys = Object.keys(config).filter(function(k) {
+					return "key" !== k;
+				});
+				isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+				didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error("A props object containing a \"key\" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />", isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = !0);
+			}
+			children = null;
+			void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+			hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+			if ("key" in config) {
+				maybeKey = {};
+				for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+			} else maybeKey = config;
+			children && defineKeyPropWarningGetter(maybeKey, "function" === typeof type ? type.displayName || type.name || "Unknown" : type);
+			return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+		}
+		function validateChildKeys(node) {
+			isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+		}
+		function isValidElement(object) {
+			return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		var React = require_react(), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+			return null;
+		};
+		React = { react_stack_bottom_frame: function(callStackForError) {
+			return callStackForError();
+		} };
+		var specialPropKeyWarningShown;
+		var didWarnAboutElementRef = {};
+		var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)();
+		var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+		var didWarnAboutKeySpread = {};
+		exports.Fragment = REACT_FRAGMENT_TYPE;
+		exports.jsx = function(type, config, maybeKey) {
+			var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+			return jsxDEVImpl(type, config, maybeKey, !1, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+		};
+		exports.jsxs = function(type, config, maybeKey) {
+			var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+			return jsxDEVImpl(type, config, maybeKey, !0, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+		};
+	})();
+}));
+require_react_jsx_runtime_development();
+//#endregion
+export { require_react_jsx_runtime_development };