styled-components-to-stylex-codemod 0.0.39 → 0.0.41

package/dist/wrapped-component-interface-yvZ-_HMO.mjs

@@ -0,0 +1,880 @@
+import { t as createModuleResolver } from "./resolve-imports-DgSAddIF.mjs";
+import { n as toRealPath } from "./path-utils-BIpoL4Ue.mjs";
+import jscodeshift from "jscodeshift";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/internal/public-api-validation.ts
+function describeValue(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (Array.isArray(value)) return `Array(${value.length})`;
+	if (typeof value === "string") return `"${value}"`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "symbol") return value.description ? `Symbol(${value.description})` : "Symbol()";
+	if (typeof value === "function") return "[Function]";
+	if (typeof value === "object") {
+		const ctor = value?.constructor?.name ?? "Object";
+		let keys = [];
+		try {
+			keys = Object.keys(value);
+		} catch {}
+		const preview = keys.slice(0, 5).join(", ");
+		const suffix = keys.length > 5 ? ", ..." : "";
+		return keys.length ? `${ctor} { ${preview}${suffix} }` : ctor;
+	}
+	return "[Unknown]";
+}
+/** Validates that the candidate is a fully-resolved `Adapter` (externalInterface must be a function). */
+function assertValidAdapter(candidate, where) {
+	assertAdapterShape(candidate, where, false);
+}
+/** Validates that the candidate is a valid `AdapterInput` (externalInterface may be `"auto"` or a function). */
+function assertValidAdapterInput(candidate, where) {
+	assertAdapterShape(candidate, where, true);
+}
+function assertAdapterShape(candidate, where, allowAutoExtIf) {
+	const obj = candidate;
+	const resolveValue = obj?.resolveValue;
+	const resolveCall = obj?.resolveCall;
+	const resolveSelector = obj?.resolveSelector;
+	const resolveBaseComponent = obj?.resolveBaseComponent;
+	const externalInterface = obj?.externalInterface;
+	if (!candidate || typeof candidate !== "object") throw new Error([
+		`${where}: expected an adapter object.`,
+		`Received: ${describeValue(candidate)}`,
+		"",
+		"Adapter requirements:",
+		"  - adapter.resolveValue(context) is required",
+		"  - adapter.resolveCall(context) is required",
+		"  - adapter.resolveSelector(context) is required",
+		"  - adapter.externalInterface(context) is required",
+		"",
+		"resolveValue(context) is called with one of these shapes:",
+		"  - { kind: \"theme\", path }",
+		"  - { kind: \"cssVariable\", name, fallback?, definedValue? }",
+		"  - { kind: \"importedValue\", importedName, source, path? }",
+		"",
+		"resolveCall(context) is called with:",
+		"  - { callSiteFilePath, calleeImportedName, calleeSource, args }",
+		"",
+		"resolveSelector(context) is called with:",
+		"  - { kind: \"selectorInterpolation\", importedName, source, path? }",
+		"  - { kind: \"mediaQueryInterpolation\", importedName, source, path?, mediaQuery }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (typeof resolveValue !== "function") throw new Error([
+		`${where}: adapter.resolveValue must be a function.`,
+		`Received: resolveValue=${describeValue(resolveValue)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveValue(context) {",
+		"      // theme/cssVariable -> { expr, imports, dropDefinition? } | null",
+		"    }",
+		"    resolveCall(context) { return { expr, imports } | null }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (typeof resolveCall !== "function") throw new Error([
+		`${where}: adapter.resolveCall must be a function.`,
+		`Received: resolveCall=${describeValue(resolveCall)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveCall(context) { return { expr: string, imports: ImportSpec[] } | null }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (typeof resolveSelector !== "function") throw new Error([
+		`${where}: adapter.resolveSelector must be a function.`,
+		`Received: resolveSelector=${describeValue(resolveSelector)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveSelector(context) { return { kind: \"media\" | \"pseudoAlias\" | \"pseudoExpand\", ... } | undefined }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (resolveBaseComponent !== void 0 && typeof resolveBaseComponent !== "function") throw new Error([
+		`${where}: adapter.resolveBaseComponent must be a function when provided.`,
+		`Received: resolveBaseComponent=${describeValue(resolveBaseComponent)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveBaseComponent(context) {",
+		"      return { tagName, consumedProps, sx?, mixins? } | undefined",
+		"    }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (!(typeof externalInterface === "function" || allowAutoExtIf && externalInterface === "auto")) throw new Error([`${where}: ${allowAutoExtIf ? "adapter.externalInterface must be a function or \"auto\"." : "adapter.externalInterface must be a function."}`, `Received: externalInterface=${describeValue(externalInterface)}`].join("\n"));
+	const styleMerger = obj?.styleMerger;
+	if (styleMerger !== null && styleMerger !== void 0) {
+		if (typeof styleMerger !== "object") throw new Error([
+			`${where}: adapter.styleMerger must be null or an object.`,
+			`Received: styleMerger=${describeValue(styleMerger)}`,
+			"",
+			"Expected shape:",
+			"  {",
+			"    functionName: \"stylexProps\",",
+			"    importSource: { kind: \"specifier\", value: \"@company/ui-utils\" }",
+			"  }"
+		].join("\n"));
+		const { functionName, importSource } = styleMerger;
+		assertFunctionNameAndImportSource({
+			where,
+			configPath: "adapter.styleMerger",
+			functionName,
+			importSource,
+			specifierExample: "@company/ui-utils",
+			absolutePathExample: "/path/to/module.ts"
+		});
+	}
+	const markerFile = obj?.markerFile;
+	if (markerFile !== void 0 && markerFile !== null && typeof markerFile !== "function") throw new Error([
+		`${where}: adapter.markerFile must be a function when provided.`,
+		`Received: markerFile=${describeValue(markerFile)}`,
+		"",
+		"Expected signature:",
+		"  markerFile(ctx: { filePath: string }) => { kind: \"specifier\" | \"absolutePath\", value: string }"
+	].join("\n"));
+	const wrappedComponentInterface = obj?.wrappedComponentInterface;
+	if (wrappedComponentInterface !== void 0 && wrappedComponentInterface !== null && typeof wrappedComponentInterface !== "function") throw new Error([
+		`${where}: adapter.wrappedComponentInterface must be a function when provided.`,
+		`Received: wrappedComponentInterface=${describeValue(wrappedComponentInterface)}`,
+		"",
+		"Expected signature:",
+		"  wrappedComponentInterface(ctx: { localName: string; importSource: string; importedName: string; filePath: string })",
+		"    => { acceptsSx: boolean } | undefined"
+	].join("\n"));
+	const themeHook = obj?.themeHook;
+	if (themeHook !== null && themeHook !== void 0) {
+		if (typeof themeHook !== "object") throw new Error([
+			`${where}: adapter.themeHook must be an object when provided.`,
+			`Received: themeHook=${describeValue(themeHook)}`,
+			"",
+			"Expected shape:",
+			"  {",
+			"    functionName: \"useTheme\",",
+			"    importSource: { kind: \"specifier\", value: \"@company/theme-hooks\" }",
+			"  }"
+		].join("\n"));
+		const { functionName, importSource } = themeHook;
+		assertFunctionNameAndImportSource({
+			where,
+			configPath: "adapter.themeHook",
+			functionName,
+			importSource,
+			specifierExample: "@company/theme-hooks",
+			absolutePathExample: "/path/to/theme-hooks.ts"
+		});
+	}
+}
+function assertFunctionNameAndImportSource(args) {
+	const { where, configPath, functionName, importSource, specifierExample, absolutePathExample } = args;
+	if (typeof functionName !== "string" || !functionName.trim()) throw new Error([`${where}: ${configPath}.functionName must be a non-empty string.`, `Received: functionName=${describeValue(functionName)}`].join("\n"));
+	if (!importSource || typeof importSource !== "object") throw new Error([
+		`${where}: ${configPath}.importSource must be an object.`,
+		`Received: importSource=${describeValue(importSource)}`,
+		"",
+		"Expected shape:",
+		`  { kind: "specifier", value: "${specifierExample}" }`,
+		"  or",
+		`  { kind: "absolutePath", value: "${absolutePathExample}" }`
+	].join("\n"));
+	const { kind, value } = importSource;
+	if (kind !== "specifier" && kind !== "absolutePath") throw new Error([`${where}: ${configPath}.importSource.kind must be "specifier" or "absolutePath".`, `Received: kind=${describeValue(kind)}`].join("\n"));
+	if (typeof value !== "string" || !value.trim()) throw new Error([`${where}: ${configPath}.importSource.value must be a non-empty string.`, `Received: value=${describeValue(value)}`].join("\n"));
+}
+const ADAPTER_DOCS_URL = `https://github.com/skovhus/styled-components-to-stylex-codemod#adapter`;
+//#endregion
+//#region src/adapter.ts
+/**
+* Adapter entry point for customizing the codemod.
+* Core concepts: value resolution hooks and adapter validation.
+*/
+/**
+* Type guard: checks whether a resolve result is a directional expansion.
+*/
+function isDirectionalResult(r) {
+	return "directional" in r;
+}
+const DEFAULT_THEME_HOOK = {
+	functionName: "useTheme",
+	importSource: {
+		kind: "specifier",
+		value: "styled-components"
+	}
+};
+/**
+* Helper for nicer user authoring + type inference.
+*
+* `defineAdapter(...)` also performs runtime validation (helpful for JS consumers)
+* and will throw a descriptive error message if the adapter shape is invalid.
+*
+* Usage:
+*   export default defineAdapter({
+*     resolveValue(ctx) {
+*       if (ctx.kind === "theme") {
+*         // For shorthand properties with multi-value tokens, return directional entries
+*         if (ctx.cssProperty === "padding" && ctx.path === "input.padding") {
+*           return {
+*             directional: [
+*               { prop: "paddingBlock", expr: "$input.paddingBlock", imports: [{ from: { kind: "specifier", value: "./tokens" }, names: [{ imported: "$input" }] }] },
+*               { prop: "paddingInline", expr: "$input.paddingInline", imports: [{ from: { kind: "specifier", value: "./tokens" }, names: [{ imported: "$input" }] }] },
+*             ],
+*           };
+*         }
+*         return {
+*           expr: `tokens.${ctx.path}`,
+*           imports: [
+*             { from: { kind: "specifier", value: "./tokens" }, names: [{ imported: "tokens" }] },
+*           ],
+*         };
+*       }
+*       // Return undefined to bail/skip the file
+*     },
+*
+*     resolveCall(ctx) {
+*       // Resolve helper calls inside template interpolations.
+*       // Use ctx.cssProperty to determine context:
+*       // - If ctx.cssProperty exists → return a CSS value expression
+*       // - If ctx.cssProperty is undefined → return a StyleX style object reference
+*       // Return { expr, imports } or undefined to bail/skip the file
+*       void ctx;
+*     },
+*
+*     resolveSelector(ctx) {
+*       // Resolve imported values used in selector position.
+*       // Return one of:
+*       // - { kind: "media", expr, imports } for media queries (e.g., breakpoints.phone)
+*       // - { kind: "pseudoAlias", values, styleSelectorExpr?, imports? } for pseudo-class expansion
+*       // - undefined to bail/skip the file
+*       // For @media placeholders, check ctx.kind === "mediaQueryInterpolation" and
+*       // use ctx.mediaQuery.feature to choose the correct defineConsts media key.
+*       void ctx;
+*     },
+*
+*     // Configure external interface for exported components
+*     externalInterface(ctx) {
+*       // Example: Enable styles, `as`, and `ref` for shared components folder
+*       if (ctx.filePath.includes("/shared/components/")) {
+*         return { styles: true, as: true, ref: true };
+*       }
+*       return { styles: false, as: false, ref: false };
+*     },
+*
+*     // Optional: provide a custom merger, or use `null` for the default verbose merge output
+*     styleMerger: null,
+*
+*     // Emit sx={} JSX attributes instead of {...stylex.props()} spreads (requires StyleX ≥0.18)
+*     useSxProp: false,
+*
+*     // Opt out of logical properties — use paddingTop/Right/Bottom/Left instead of Block/Inline
+*     // usePhysicalProperties: true,
+*
+*     // Optional: customize runtime theme hook import/call used by emitted wrappers
+*     themeHook: {
+*       functionName: "useTheme",
+*       importSource: { kind: "specifier", value: "styled-components" },
+*     },
+*   });
+*/
+function defineAdapter(adapter) {
+	assertValidAdapterInput(adapter, "defineAdapter(adapter)");
+	return adapter;
+}
+//#endregion
+//#region src/internal/merge-markers.ts
+/**
+* Shared utility for merging marker sidecar content.
+* Core concepts: deduplication of defineMarker declarations across files.
+*/
+/** Regex matching a marker block: optional JSDoc comment followed by the export line. */
+const MARKER_BLOCK_RE = /(?:\/\*\*[^]*?\*\/\n)?export const \w+ = stylex\.defineMarker\(\);/gm;
+/** Regex matching just the export line (used for dedup checks). */
+const MARKER_EXPORT_RE = /^export const \w+ = stylex\.defineMarker\(\);$/gm;
+/** Regex matching a generated defineVars export block. */
+const DEFINE_VARS_BLOCK_RE = /export const \w+ = stylex\.defineVars\(\{\n[\s\S]*?\n\}\);/gm;
+/** Regex matching just the defineVars export line (used for dedup checks). */
+const DEFINE_VARS_EXPORT_RE = /^export const \w+ = stylex\.defineVars\(\{$/gm;
+/**
+* Merge marker declarations from `incoming` into `base`, appending only new
+* marker blocks (JSDoc + export). Returns `base` unchanged if all markers already exist.
+*/
+function mergeMarkerDeclarations(base, incoming) {
+	const mergedDefineVars = mergeDefineVarsBlocks(base, incoming);
+	const markerBlocks = getNewBlocks({
+		base: mergedDefineVars,
+		incoming,
+		blockRegex: MARKER_BLOCK_RE,
+		exportRegex: MARKER_EXPORT_RE
+	});
+	const defineVarsBlocks = getNewBlocks({
+		base: mergedDefineVars,
+		incoming,
+		blockRegex: DEFINE_VARS_BLOCK_RE,
+		exportRegex: DEFINE_VARS_EXPORT_RE
+	});
+	const blocksToAdd = [...markerBlocks, ...defineVarsBlocks];
+	if (blocksToAdd.length === 0) return mergedDefineVars;
+	let merged = mergedDefineVars;
+	if (!merged.includes("@stylexjs/stylex")) merged = `import * as stylex from "@stylexjs/stylex";\n\n${merged}`;
+	return merged.trimEnd() + "\n\n" + blocksToAdd.join("\n\n") + "\n";
+}
+function getNewBlocks(args) {
+	const { base, incoming, blockRegex, exportRegex } = args;
+	const incomingExports = [...incoming.matchAll(exportRegex)].map((m) => m[0]);
+	if (incomingExports.length === 0) return [];
+	const newExportLines = incomingExports.filter((line) => !base.includes(line));
+	if (newExportLines.length === 0) return [];
+	const newExportSet = new Set(newExportLines);
+	return [...incoming.matchAll(blockRegex)].map((m) => m[0]).filter((block) => {
+		const exportLine = block.match(exportRegex);
+		return exportLine && newExportSet.has(exportLine[0]);
+	});
+}
+function mergeDefineVarsBlocks(base, incoming) {
+	let merged = base;
+	for (const incomingBlock of incoming.matchAll(DEFINE_VARS_BLOCK_RE)) {
+		const incomingText = incomingBlock[0];
+		const exportName = readDefineVarsExportName(incomingText);
+		if (!exportName) continue;
+		const existingBlock = findDefineVarsBlockByExportName(merged, exportName);
+		if (!existingBlock) continue;
+		const entriesToAdd = getMissingDefineVarsEntries({
+			existingBlock: existingBlock.text,
+			incomingBlock: incomingText
+		});
+		if (entriesToAdd.length === 0) continue;
+		const insertionPoint = existingBlock.start + existingBlock.text.lastIndexOf("\n});");
+		const linesToAdd = entriesToAdd.map((entry) => entry.line);
+		merged = `${merged.slice(0, insertionPoint)}\n${linesToAdd.join("\n")}${merged.slice(insertionPoint)}`;
+	}
+	return merged;
+}
+function readDefineVarsExportName(block) {
+	return /^export const ([A-Za-z_$][\w$]*) = stylex\.defineVars\(\{/m.exec(block)?.[1] ?? null;
+}
+function findDefineVarsBlockByExportName(source, exportName) {
+	for (const match of source.matchAll(DEFINE_VARS_BLOCK_RE)) {
+		const text = match[0];
+		if (readDefineVarsExportName(text) === exportName && match.index !== void 0) return {
+			text,
+			start: match.index
+		};
+	}
+	return null;
+}
+function getMissingDefineVarsEntries(args) {
+	const { existingBlock, incomingBlock } = args;
+	const existingKeys = new Set(readDefineVarsEntryKeys(existingBlock));
+	return readDefineVarsEntries(incomingBlock).filter((entry) => !existingKeys.has(entry.key));
+}
+function readDefineVarsEntryKeys(block) {
+	return readDefineVarsEntries(block).map((entry) => entry.key);
+}
+function readDefineVarsEntries(block) {
+	return block.split("\n").map((line) => ({
+		line,
+		match: /^\s*(?:(["']--[^"']+["'])|([A-Za-z_$][\w$]*))\s*:/.exec(line)
+	})).filter((entry) => Boolean(entry.match)).map(({ line, match }) => ({
+		key: normalizeDefineVarsEntryKey(match[1] ?? match[2]),
+		line
+	}));
+}
+function normalizeDefineVarsEntryKey(key) {
+	if (key.length >= 2 && (key.startsWith("\"") && key.endsWith("\"") || key.startsWith("'") && key.endsWith("'"))) return key.slice(1, -1);
+	return key;
+}
+//#endregion
+//#region src/internal/wrapped-component-interface.ts
+/**
+* Decides whether a `styled(Component)` wraps a component that already
+* accepts a StyleX `sx` prop. When true, the codemod emits `sx={style}`
+* instead of `{...stylex.props(style)}` on the wrapped element.
+*
+* Two signals are consulted, in order:
+*   1. The adapter `wrappedComponentInterface` hook — explicit override.
+*   2. Static auto-detection of an `sx?: …` member on the imported
+*      component's props type, or on a same-file component's props type when
+*      the current source is provided.
+*
+* Used by both the wrapper-emitter (full wrapper components) and the
+* JSX-rewrite step (inlined re-styles).
+*/
+function detectExportedComponentSxProp(args) {
+	return detectExportedSxProp(args.absolutePath, args.componentName, args.sourceOverrides, args.visited ?? /* @__PURE__ */ new Set());
+}
+function isWrappedComponentSxAware(args) {
+	const { adapter, importMap, componentLocalName, filePath, localSource, sourceOverrides } = args;
+	if (!adapter.useSxProp) return false;
+	const importInfo = importMap?.get(componentLocalName);
+	if (!importInfo) {
+		const source = readSourceOverride(filePath, sourceOverrides) ?? localSource;
+		return source ? computeDetectionFromSource(source, componentLocalName, filePath, sourceOverrides) : false;
+	}
+	const adapterResult = adapter.wrappedComponentInterface?.({
+		localName: componentLocalName,
+		importSource: importInfo.source.value,
+		importedName: importInfo.importedName,
+		filePath
+	});
+	if (adapterResult !== void 0) return adapterResult.acceptsSx === true;
+	const absolutePath = resolveWrappedComponentSource(importInfo.source, filePath);
+	if (!absolutePath) return false;
+	return detectExportedComponentSxProp({
+		absolutePath,
+		componentName: importInfo.importedName,
+		sourceOverrides
+	});
+}
+const FILE_EXTENSIONS = [
+	"",
+	".tsx",
+	".ts",
+	".jsx",
+	".js"
+];
+const SX_PROP_NAME = "sx";
+const moduleResolver = createModuleResolver();
+/**
+* Cache keyed by `absolutePath\u0000componentName`. Detection requires reading
+* and parsing the source file, so memoize across the many `styled(X)` lookups
+* that happen during a single transform pass.
+*/
+const detectionCache = /* @__PURE__ */ new Map();
+function resolveWrappedComponentSource(source, filePath) {
+	if (source.kind === "absolutePath") return source.value;
+	return moduleResolver.resolve(filePath, source.value) ?? null;
+}
+function detectExportedSxProp(absolutePath, componentName, sourceOverrides, visited = /* @__PURE__ */ new Set()) {
+	const sourcePath = resolveSourcePath(absolutePath) ?? absolutePath;
+	const visitKey = `${toRealPath(sourcePath)}\u0000${componentName}`;
+	if (visited.has(visitKey)) return false;
+	visited.add(visitKey);
+	const sourceOverride = readSourceOverride(absolutePath, sourceOverrides);
+	if (sourceOverride !== void 0) return computeDetectionFromSource(sourceOverride, componentName, sourcePath, sourceOverrides, visited);
+	const cacheKey = `${absolutePath}\u0000${componentName}`;
+	if (!sourceOverrides) {
+		const cached = detectionCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+	}
+	const result = computeDetection(absolutePath, componentName, visited, sourceOverrides);
+	if (!sourceOverrides) detectionCache.set(cacheKey, result);
+	return result;
+}
+function computeDetection(absolutePath, componentName, visited, sourceOverrides) {
+	const resolved = resolveSourcePath(absolutePath);
+	if (!resolved) return false;
+	let source;
+	try {
+		source = readFileSync(resolved, "utf8");
+	} catch {
+		return false;
+	}
+	return computeDetectionFromSource(source, componentName, resolved, sourceOverrides, visited);
+}
+function computeDetectionFromSource(source, componentName, filePath, sourceOverrides, visited = /* @__PURE__ */ new Set()) {
+	if (!source.includes(componentName) && !sourceHasReExports(source)) return false;
+	const parsed = parseSource(source);
+	if (!parsed) return false;
+	const { j, root } = parsed;
+	const propsTypeNode = findComponentPropsType(root, componentName);
+	if (!propsTypeNode) return filePath ? detectReExportedSxProp(root, componentName, filePath, sourceOverrides, visited) : false;
+	return typeMentionsSxMember({
+		j,
+		root,
+		filePath,
+		sourceOverrides,
+		visited,
+		visitedTypeNames: /* @__PURE__ */ new Set()
+	}, propsTypeNode);
+}
+function parseSource(source) {
+	try {
+		const j = jscodeshift.withParser("tsx");
+		return {
+			j,
+			root: j(source)
+		};
+	} catch {
+		return null;
+	}
+}
+function isKnownPropPreservingHocCallee(callee) {
+	const node = callee;
+	if (!node) return false;
+	if (node.type === "Identifier") return node.name === "memo" || node.name === "forwardRef";
+	return node.type === "MemberExpression" && node.property?.type === "Identifier" && (node.property.name === "memo" || node.property.name === "forwardRef");
+}
+function resolveSourcePath(absolutePath) {
+	for (const candidate of sourcePathCandidates(absolutePath)) if (existsSync(candidate)) return candidate;
+	return null;
+}
+function readSourceOverride(absolutePath, sourceOverrides) {
+	if (!sourceOverrides) return;
+	for (const candidate of sourcePathCandidates(absolutePath)) {
+		const source = sourceOverrides.get(toRealPath(candidate));
+		if (source !== void 0) return source;
+	}
+}
+function sourcePathCandidates(absolutePath) {
+	return FILE_EXTENSIONS.map((ext) => absolutePath + ext);
+}
+/**
+* Locate a top-level `componentName` declaration in `root` and return the TS
+* type annotation of its first parameter, or null.
+*
+* Handles:
+*   - `export function Name(props: T)` and `export default function Name(...)`.
+*   - `export const Name = (props: T) => …` / arrow function variants.
+*/
+function findComponentPropsType(root, componentName) {
+	let propsType = null;
+	const recordFromParam = (params) => {
+		if (propsType || !Array.isArray(params) || params.length === 0) return;
+		const ann = params[0]?.typeAnnotation?.typeAnnotation;
+		if (ann) propsType = ann;
+	};
+	const recordFromInit = (init) => {
+		if (propsType || !init || typeof init !== "object") return;
+		const node = init;
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+			recordFromParam(node.params);
+			return;
+		}
+		if (node.type !== "CallExpression" || !Array.isArray(node.arguments)) return;
+		const canFollowIdentifierArguments = isKnownPropPreservingHocCallee(node.callee);
+		for (const arg of node.arguments) {
+			const argNode = arg;
+			if (canFollowIdentifierArguments && argNode.type === "Identifier" && argNode.name) {
+				recordFromNamedDeclaration(argNode.name);
+				if (propsType) return;
+				continue;
+			}
+			recordFromInit(arg);
+			if (propsType) return;
+		}
+	};
+	const recordFromNamedDeclaration = (name) => {
+		if (propsType) return;
+		const body = root.get().node.program.body;
+		for (const statement of body) {
+			const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+			if (!declaration) continue;
+			if (declaration.type === "FunctionDeclaration") {
+				if (declaration.id?.name === name) {
+					recordFromParam(declaration.params);
+					return;
+				}
+				continue;
+			}
+			if (declaration.type !== "VariableDeclaration") continue;
+			for (const declarator of declaration.declarations) {
+				const id = declarator.id;
+				if (id.type === "Identifier" && id.name === name) {
+					recordFromInit(declarator.init);
+					return;
+				}
+			}
+		}
+	};
+	if (componentName === "default") {
+		const body = root.get().node.program.body;
+		for (const statement of body) {
+			if (statement.type !== "ExportDefaultDeclaration") continue;
+			const declaration = statement.declaration;
+			if (!declaration) continue;
+			if (declaration.type === "FunctionDeclaration" || declaration.type === "FunctionExpression" || declaration.type === "ArrowFunctionExpression") {
+				recordFromParam(declaration.params);
+				return propsType;
+			}
+			if (declaration.type === "Identifier" && declaration.name) {
+				recordFromNamedDeclaration(declaration.name);
+				return propsType;
+			}
+			recordFromInit(declaration);
+			return propsType;
+		}
+		return null;
+	}
+	const body = root.get().node.program.body;
+	for (const statement of body) {
+		const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+		if (!declaration) continue;
+		if (declaration.type === "FunctionDeclaration") {
+			if (declaration.id?.name === componentName) recordFromParam(declaration.params);
+			continue;
+		}
+		if (declaration.type !== "VariableDeclaration") continue;
+		for (const declarator of declaration.declarations) {
+			const id = declarator.id;
+			if (id.type !== "Identifier" || id.name !== componentName) continue;
+			recordFromInit(declarator.init);
+		}
+	}
+	return propsType;
+}
+function detectReExportedSxProp(root, componentName, filePath, sourceOverrides, visited) {
+	const body = root.get().node.program.body;
+	for (const statement of body) {
+		if (statement.type !== "ExportNamedDeclaration" && statement.type !== "ExportAllDeclaration") continue;
+		const source = statement.source?.value;
+		if (typeof source !== "string") continue;
+		let sourceComponentName = componentName;
+		if (statement.type === "ExportNamedDeclaration") {
+			let forwardedName = null;
+			for (const specifier of statement.specifiers ?? []) {
+				const spec = specifier;
+				if (spec.type !== "ExportSpecifier") continue;
+				const exportedName = getModuleName(spec.exported);
+				if (exportedName !== componentName) continue;
+				forwardedName = getModuleName(spec.local) ?? exportedName;
+				break;
+			}
+			if (!forwardedName) continue;
+			sourceComponentName = forwardedName;
+		}
+		const resolvedPath = moduleResolver.resolve(filePath, source);
+		if (resolvedPath && detectExportedComponentSxProp({
+			absolutePath: resolvedPath,
+			componentName: sourceComponentName,
+			sourceOverrides,
+			visited
+		})) return true;
+	}
+	return false;
+}
+function sourceHasReExports(source) {
+	return /\bexport\s+(?:\*|\{)/.test(source);
+}
+function getModuleName(node) {
+	const n = node;
+	if (!n) return null;
+	if (n.type === "Identifier") return n.name ?? null;
+	return typeof n.value === "string" ? n.value : null;
+}
+function typeMentionsSxMember(ctx, node) {
+	const n = node;
+	switch (n.type) {
+		case "TSTypeLiteral": return literalContainsSxMember(n.members);
+		case "TSIntersectionType":
+		case "TSUnionType":
+			for (const member of n.types ?? []) if (typeMentionsSxMember(ctx, member)) return true;
+			return false;
+		case "TSParenthesizedType": return n.typeAnnotation ? typeMentionsSxMember(ctx, n.typeAnnotation) : false;
+		case "TSTypeReference": {
+			const typeName = getTypeReferenceName(n.typeName);
+			return typeName ? typeReferenceNameMentionsSx(ctx, typeName, { allowImported: true }) : false;
+		}
+		default: return false;
+	}
+}
+function getTypeReferenceName(typeName) {
+	if (typeName?.type === "Identifier" && typeName.name) return {
+		kind: "identifier",
+		name: typeName.name
+	};
+	if (typeName?.type === "TSQualifiedName" && typeName.left?.type === "Identifier" && typeName.left.name && typeName.right?.type === "Identifier" && typeName.right.name) return {
+		kind: "qualified",
+		namespace: typeName.left.name,
+		name: typeName.right.name
+	};
+	return null;
+}
+function typeReferenceNameMentionsSx(ctx, typeName, options) {
+	if (typeName.kind === "qualified") return options.allowImported ? importedNamespaceTypeReferenceMentionsSx(ctx, typeName) : false;
+	return typeReferenceMentionsSx(ctx, typeName.name, options);
+}
+function typeReferenceMentionsSx(ctx, typeName, options) {
+	const visitedKey = `${ctx.filePath ?? "<memory>"}\u0000${typeName}`;
+	if (ctx.visitedTypeNames.has(visitedKey)) return false;
+	ctx.visitedTypeNames.add(visitedKey);
+	const aliased = ctx.root.find(ctx.j.TSTypeAliasDeclaration).filter((p) => {
+		return p.node.id?.name === typeName;
+	});
+	if (aliased.size() > 0) {
+		const annotation = aliased.get().node.typeAnnotation;
+		if (annotation && typeMentionsSxMember(ctx, annotation)) return true;
+	}
+	const iface = ctx.root.find(ctx.j.TSInterfaceDeclaration).filter((p) => {
+		return p.node.id?.name === typeName;
+	});
+	if (iface.size() > 0) {
+		const node = iface.get().node;
+		if (literalContainsSxMember(node.body?.body)) return true;
+		if (interfaceExtendsMentionSx(ctx, node.extends)) return true;
+	}
+	if (typeName === "default" && defaultExportedTypeDeclarationMentionsSx(ctx)) return true;
+	if (exportedTypeReferenceMentionsSx(ctx, typeName)) return true;
+	return options.allowImported ? importedTypeReferenceMentionsSx(ctx, typeName) : false;
+}
+function defaultExportedTypeDeclarationMentionsSx(ctx) {
+	const body = ctx.root.get().node.program.body;
+	for (const statement of body) {
+		if (statement.type !== "ExportDefaultDeclaration") continue;
+		const declaration = statement.declaration;
+		if (!declaration) continue;
+		if (declaration.type === "TSInterfaceDeclaration") return literalContainsSxMember(declaration.body?.body) || interfaceExtendsMentionSx(ctx, declaration.extends);
+		if (declaration.type === "TSTypeAliasDeclaration" && declaration.typeAnnotation) return typeMentionsSxMember(ctx, declaration.typeAnnotation);
+		if (declaration.type === "Identifier" && typeof declaration.name === "string") return typeReferenceMentionsSx(ctx, declaration.name, { allowImported: true });
+	}
+	return false;
+}
+function exportedTypeReferenceMentionsSx(ctx, typeName) {
+	if (!ctx.filePath) return false;
+	const body = ctx.root.get().node.program.body;
+	for (const statement of body) {
+		if (statement.type === "ExportAllDeclaration") {
+			const source = statement.source?.value;
+			if (typeof source !== "string") continue;
+			const resolvedPath = moduleResolver.resolve(ctx.filePath, source);
+			if (!resolvedPath) continue;
+			const sourceText = readSourceOverride(resolvedPath, ctx.sourceOverrides) ?? readSource(resolvedPath);
+			if (!sourceText) continue;
+			const parsed = parseSource(sourceText);
+			if (!parsed) continue;
+			if (typeReferenceMentionsSx({
+				...ctx,
+				j: parsed.j,
+				root: parsed.root,
+				filePath: resolvedPath
+			}, typeName, { allowImported: true })) return true;
+			continue;
+		}
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		const source = statement.source?.value;
+		for (const specifier of statement.specifiers ?? []) {
+			const spec = specifier;
+			if (spec.type !== "ExportSpecifier" && spec.type !== "ExportTypeSpecifier") continue;
+			const exportedName = getModuleName(spec.exported);
+			if (exportedName !== typeName) continue;
+			const sourceName = getModuleName(spec.local) ?? exportedName;
+			if (typeof source !== "string") {
+				if (typeReferenceMentionsSx(ctx, sourceName, { allowImported: true })) return true;
+				continue;
+			}
+			const resolvedPath = moduleResolver.resolve(ctx.filePath, source);
+			if (!resolvedPath) continue;
+			const sourceText = readSourceOverride(resolvedPath, ctx.sourceOverrides) ?? readSource(resolvedPath);
+			if (!sourceText) continue;
+			const parsed = parseSource(sourceText);
+			if (!parsed) continue;
+			if (typeReferenceMentionsSx({
+				...ctx,
+				j: parsed.j,
+				root: parsed.root,
+				filePath: resolvedPath
+			}, sourceName, { allowImported: true })) return true;
+		}
+	}
+	return false;
+}
+function interfaceExtendsMentionSx(ctx, heritage) {
+	if (!Array.isArray(heritage)) return false;
+	for (const item of heritage) {
+		const typeName = getHeritageTypeName(item);
+		if (typeName && typeReferenceNameMentionsSx(ctx, typeName, { allowImported: true })) return true;
+	}
+	return false;
+}
+function getHeritageTypeName(node) {
+	if (!node || typeof node !== "object") return null;
+	const n = node;
+	return getTypeReferenceName(n.expression) ?? getTypeReferenceName(n.typeName);
+}
+function importedTypeReferenceMentionsSx(ctx, localTypeName) {
+	const importInfo = findTypeImport(ctx.root, localTypeName);
+	if (!importInfo || !ctx.filePath) return false;
+	const resolvedPath = moduleResolver.resolve(ctx.filePath, importInfo.source);
+	if (!resolvedPath) return false;
+	const source = readSourceOverride(resolvedPath, ctx.sourceOverrides) ?? readSource(resolvedPath);
+	if (!source) return false;
+	const parsed = parseSource(source);
+	if (!parsed) return false;
+	return typeReferenceMentionsSx({
+		...ctx,
+		j: parsed.j,
+		root: parsed.root,
+		filePath: resolvedPath
+	}, importInfo.importedName, { allowImported: true });
+}
+function importedNamespaceTypeReferenceMentionsSx(ctx, typeName) {
+	const importInfo = findNamespaceTypeImport(ctx.root, typeName.namespace);
+	if (!importInfo || !ctx.filePath) return false;
+	const resolvedPath = moduleResolver.resolve(ctx.filePath, importInfo.source);
+	if (!resolvedPath) return false;
+	const source = readSourceOverride(resolvedPath, ctx.sourceOverrides) ?? readSource(resolvedPath);
+	if (!source) return false;
+	const parsed = parseSource(source);
+	if (!parsed) return false;
+	return typeReferenceMentionsSx({
+		...ctx,
+		j: parsed.j,
+		root: parsed.root,
+		filePath: resolvedPath
+	}, typeName.name, { allowImported: true });
+}
+function findTypeImport(root, localTypeName) {
+	const body = root.get().node.program.body;
+	for (const statement of body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const source = statement.source.value;
+		if (typeof source !== "string") continue;
+		for (const specifier of statement.specifiers ?? []) {
+			const spec = specifier;
+			if (spec.local?.name !== localTypeName) continue;
+			if (spec.type === "ImportSpecifier") {
+				const importedName = spec.imported?.name ?? (typeof spec.imported?.value === "string" ? spec.imported.value : void 0);
+				return importedName ? {
+					importedName,
+					source
+				} : null;
+			}
+			if (spec.type === "ImportDefaultSpecifier") return {
+				importedName: "default",
+				source
+			};
+		}
+	}
+	return null;
+}
+function findNamespaceTypeImport(root, localNamespace) {
+	const body = root.get().node.program.body;
+	for (const statement of body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const source = statement.source.value;
+		if (typeof source !== "string") continue;
+		for (const specifier of statement.specifiers ?? []) {
+			const spec = specifier;
+			if (spec.type === "ImportNamespaceSpecifier" && spec.local?.name === localNamespace) return { source };
+		}
+	}
+	return null;
+}
+function readSource(absolutePath) {
+	const resolved = resolveSourcePath(absolutePath);
+	if (!resolved) return null;
+	try {
+		return readFileSync(resolved, "utf8");
+	} catch {
+		return null;
+	}
+}
+function literalContainsSxMember(members) {
+	if (!Array.isArray(members)) return false;
+	for (const member of members) {
+		const m = member;
+		if (m?.type !== "TSPropertySignature" || !m.key) continue;
+		if ((m.key.type === "Identifier" ? m.key.name : (m.key.type === "StringLiteral" || m.key.type === "Literal") && typeof m.key.value === "string" ? m.key.value : null) === SX_PROP_NAME) return true;
+	}
+	return false;
+}
+//#endregion
+export { defineAdapter as a, assertValidAdapterInput as c, DEFAULT_THEME_HOOK as i, describeValue as l, isWrappedComponentSxAware as n, isDirectionalResult as o, mergeMarkerDeclarations as r, assertValidAdapter as s, detectExportedComponentSxProp as t };