dittory 0.0.2 → 0.0.3

package/dist/analyzeProps-B0TjCZhP.mjs

@@ -0,0 +1,1103 @@
+import { Node, SyntaxKind } from "ts-morph";
+
+//#region src/source/fileFilters.ts
+/**
+* ファイルパスがテストファイルまたはStorybookファイルかどうかを判定する
+* - 拡張子が .test.* / .spec.* / .stories.* のファイル
+* - __tests__ / __stories__ フォルダ内のファイル
+*/
+function isTestOrStorybookFile(filePath) {
+	if (/\.(test|spec|stories)\.(ts|tsx|js|jsx)$/.test(filePath)) return true;
+	if (/\b__tests__\b|\b__stories__\b/.test(filePath)) return true;
+	return false;
+}
+
+//#endregion
+//#region src/extraction/parameterUtils.ts
+/**
+* 式がパラメータ（関数の引数）を参照しているかどうかを判定する
+* ネストしたプロパティアクセス（例: props.nested.value）にも対応
+*/
+function isParameterReference(expression) {
+	if (Node.isIdentifier(expression)) {
+		const decl = expression.getSymbol()?.getDeclarations()[0];
+		if (!decl) return false;
+		const kind = decl.getKind();
+		return kind === SyntaxKind.Parameter || kind === SyntaxKind.BindingElement;
+	}
+	if (Node.isPropertyAccessExpression(expression)) return isParameterReference(expression.getExpression());
+	return false;
+}
+/**
+* 式を含む関数宣言を見つける
+*/
+function findContainingFunction(node) {
+	let current = node;
+	while (current) {
+		if (Node.isFunctionDeclaration(current) || Node.isArrowFunction(current) || Node.isFunctionExpression(current) || Node.isMethodDeclaration(current)) return current;
+		current = current.getParent();
+	}
+}
+/**
+* 関数スコープから関数名を取得する
+*/
+function getFunctionName(functionScope) {
+	if (Node.isFunctionDeclaration(functionScope)) return functionScope.getName() ?? "anonymous";
+	if (Node.isArrowFunction(functionScope) || Node.isFunctionExpression(functionScope)) {
+		const parent = functionScope.getParent();
+		if (parent && Node.isVariableDeclaration(parent)) return parent.getName();
+		return "anonymous";
+	}
+	if (Node.isMethodDeclaration(functionScope)) {
+		const className = functionScope.getParent()?.asKind(SyntaxKind.ClassDeclaration)?.getName();
+		const methodName = functionScope.getName();
+		return className ? `${className}.${methodName}` : methodName;
+	}
+	return "anonymous";
+}
+/**
+* 式からパラメータパスを構築
+* 例: props.nested.value → "props.nested.value"
+*/
+function buildParameterPath(expression) {
+	if (Node.isIdentifier(expression)) return expression.getText();
+	if (Node.isPropertyAccessExpression(expression)) return `${buildParameterPath(expression.getExpression())}.${expression.getName()}`;
+	return expression.getText();
+}
+/**
+* パラメータ参照の ArgValue を作成する
+*/
+function createParamRefValue(expression) {
+	const filePath = expression.getSourceFile().getFilePath();
+	const functionScope = findContainingFunction(expression);
+	if (!functionScope) return {
+		type: ArgValueType.Literal,
+		value: expression.getText()
+	};
+	const functionName = getFunctionName(functionScope);
+	const path = buildParameterPath(expression);
+	return {
+		type: ArgValueType.ParamRef,
+		filePath,
+		functionName,
+		path
+	};
+}
+/**
+* ArgValue を比較可能な文字列キーに変換
+* 同じ値かどうかの判定に使用
+*/
+function argValueToKey(value) {
+	switch (value.type) {
+		case ArgValueType.Literal: return `literal:${value.value}`;
+		case ArgValueType.Function: return `function:${value.filePath}:${value.line}`;
+		case ArgValueType.ParamRef: return `paramRef:${value.filePath}:${value.functionName}:${value.path}`;
+		case ArgValueType.Undefined: return "undefined";
+	}
+}
+/**
+* パラメータ参照を解決する
+* callSiteMapを使って、パラメータに渡されたすべての値を取得し、
+* すべて同じ値ならその値を返す。異なる値があればundefinedを返す。
+*
+* @param argValue - 解決対象の ArgValue
+* @param callSiteMap - 呼び出し情報マップ
+* @param visited - 循環参照防止用のセット
+* @returns 解決された ArgValue。異なる値がある場合や解決できない場合はundefined
+*/
+function resolveParameterValue(argValue, callSiteMap, visited = /* @__PURE__ */ new Set()) {
+	if (argValue.type !== ArgValueType.ParamRef) return argValue;
+	const key = argValueToKey(argValue);
+	if (visited.has(key)) return;
+	visited.add(key);
+	const { filePath, functionName, path } = argValue;
+	const targetId = `${filePath}:${functionName}`;
+	const callSiteInfo = callSiteMap.get(targetId);
+	if (!callSiteInfo) return;
+	const paramParts = path.split(".");
+	const propName = paramParts.length > 1 ? paramParts[paramParts.length - 1] : paramParts[0];
+	const args = callSiteInfo.get(propName);
+	if (!args || args.length === 0) return;
+	const resolvedKeys = /* @__PURE__ */ new Set();
+	let resolvedValue;
+	for (const arg of args) {
+		const resolved = resolveParameterValue(arg.value, callSiteMap, new Set(visited));
+		if (resolved === void 0) return;
+		const resolvedKey = argValueToKey(resolved);
+		resolvedKeys.add(resolvedKey);
+		resolvedValue = resolved;
+	}
+	if (resolvedKeys.size === 1) return resolvedValue;
+}
+
+//#endregion
+//#region src/extraction/callSiteCollector.ts
+/**
+* ArgValueのtype識別子
+*/
+const ArgValueType = {
+	Literal: "literal",
+	Function: "function",
+	ParamRef: "paramRef",
+	Undefined: "undefined"
+};
+/**
+* 関数/コンポーネントの識別子を生成する
+*/
+function createTargetId(filePath, name) {
+	return `${filePath}:${name}`;
+}
+/**
+* 式から ArgValue を抽出する
+*
+* 式の値を型安全な ArgValue として返す。
+* 呼び出し情報収集時および式の値解決時に使用する。
+*
+* @param expression - 解析対象の式ノード
+* @returns 式の値を表す ArgValue
+*/
+function extractArgValue(expression) {
+	const type = expression.getType();
+	if (type.getCallSignatures().length > 0) {
+		const sourceFile = expression.getSourceFile();
+		const line = expression.getStartLineNumber();
+		return {
+			type: ArgValueType.Function,
+			filePath: sourceFile.getFilePath(),
+			line
+		};
+	}
+	if (Node.isPropertyAccessExpression(expression)) {
+		const decl = expression.getSymbol()?.getDeclarations()[0];
+		if (decl && Node.isEnumMember(decl)) {
+			const enumDecl = decl.getParent();
+			if (Node.isEnumDeclaration(enumDecl)) {
+				const filePath = enumDecl.getSourceFile().getFilePath();
+				const enumName = enumDecl.getName();
+				const memberName = decl.getName();
+				const value = decl.getValue();
+				return {
+					type: ArgValueType.Literal,
+					value: `${filePath}:${enumName}.${memberName}=${JSON.stringify(value)}`
+				};
+			}
+		}
+		if (isParameterReference(expression.getExpression())) return createParamRefValue(expression);
+	}
+	if (Node.isIdentifier(expression)) {
+		if (expression.getText() === "undefined") return { type: ArgValueType.Undefined };
+		const symbol = expression.getSymbol();
+		const decl = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations()[0];
+		if (decl) {
+			const kind = decl.getKind();
+			if (kind === SyntaxKind.Parameter || kind === SyntaxKind.BindingElement) return createParamRefValue(expression);
+			if (Node.isVariableDeclaration(decl)) {
+				const initializer = decl.getInitializer();
+				if (initializer) return extractArgValue(initializer);
+				return {
+					type: ArgValueType.Literal,
+					value: `${decl.getSourceFile().getFilePath()}:${expression.getText()}`
+				};
+			}
+			return {
+				type: ArgValueType.Literal,
+				value: `${decl.getSourceFile().getFilePath()}:${expression.getText()}`
+			};
+		}
+	}
+	if (type.isStringLiteral() || type.isNumberLiteral()) return {
+		type: ArgValueType.Literal,
+		value: JSON.stringify(type.getLiteralValue())
+	};
+	if (type.isBooleanLiteral()) return {
+		type: ArgValueType.Literal,
+		value: type.getText()
+	};
+	return {
+		type: ArgValueType.Literal,
+		value: expression.getText()
+	};
+}
+/**
+* JSX要素から呼び出し情報を抽出
+*/
+function extractFromJsxElement(element, targetId, callSiteMap) {
+	const filePath = element.getSourceFile().getFilePath();
+	let info = callSiteMap.get(targetId);
+	if (!info) {
+		info = /* @__PURE__ */ new Map();
+		callSiteMap.set(targetId, info);
+	}
+	for (const attr of element.getAttributes()) {
+		if (!Node.isJsxAttribute(attr)) continue;
+		const propName = attr.getNameNode().getText();
+		const initializer = attr.getInitializer();
+		let value;
+		if (!initializer) value = {
+			type: ArgValueType.Literal,
+			value: "true"
+		};
+		else if (Node.isJsxExpression(initializer)) {
+			const expr = initializer.getExpression();
+			value = expr ? extractArgValue(expr) : { type: ArgValueType.Undefined };
+		} else value = {
+			type: ArgValueType.Literal,
+			value: initializer.getText()
+		};
+		const args = info.get(propName) ?? [];
+		args.push({
+			name: propName,
+			value,
+			filePath,
+			line: element.getStartLineNumber()
+		});
+		info.set(propName, args);
+	}
+}
+/**
+* 関数呼び出しから呼び出し情報を抽出
+*/
+function extractFromCallExpression(callExpr, targetId, paramNames, callSiteMap) {
+	const filePath = callExpr.getSourceFile().getFilePath();
+	let info = callSiteMap.get(targetId);
+	if (!info) {
+		info = /* @__PURE__ */ new Map();
+		callSiteMap.set(targetId, info);
+	}
+	const args = callExpr.getArguments();
+	for (let i = 0; i < paramNames.length; i++) {
+		const paramName = paramNames[i];
+		const arg = args[i];
+		const value = arg ? extractArgValue(arg) : { type: ArgValueType.Undefined };
+		const argList = info.get(paramName) ?? [];
+		argList.push({
+			name: paramName,
+			value,
+			filePath,
+			line: callExpr.getStartLineNumber()
+		});
+		info.set(paramName, argList);
+	}
+}
+/**
+* ソースファイルからすべての呼び出し情報を収集する
+*/
+function collectCallSites(sourceFiles, shouldExcludeFile = isTestOrStorybookFile) {
+	const callSiteMap = /* @__PURE__ */ new Map();
+	for (const sourceFile of sourceFiles) {
+		if (shouldExcludeFile(sourceFile.getFilePath())) continue;
+		const jsxElements = [...sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement), ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement)];
+		for (const element of jsxElements) {
+			const tagName = element.getTagNameNode();
+			if (!Node.isIdentifier(tagName)) continue;
+			const symbol = tagName.getSymbol();
+			const decl = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations()[0];
+			if (!decl) continue;
+			extractFromJsxElement(element, createTargetId(decl.getSourceFile().getFilePath(), tagName.getText()), callSiteMap);
+		}
+		const callExprs = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+		for (const callExpr of callExprs) {
+			const expr = callExpr.getExpression();
+			if (!Node.isIdentifier(expr)) continue;
+			const symbol = expr.getSymbol();
+			const decl = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations()[0];
+			if (!decl) continue;
+			let paramNames = [];
+			if (Node.isFunctionDeclaration(decl)) paramNames = decl.getParameters().map((p) => p.getName());
+			else if (Node.isVariableDeclaration(decl)) {
+				const init = decl.getInitializer();
+				if (init && Node.isArrowFunction(init)) paramNames = init.getParameters().map((p) => p.getName());
+				else if (init && Node.isFunctionExpression(init)) paramNames = init.getParameters().map((p) => p.getName());
+				else continue;
+			} else continue;
+			extractFromCallExpression(callExpr, createTargetId(decl.getSourceFile().getFilePath(), expr.getText()), paramNames, callSiteMap);
+		}
+	}
+	return callSiteMap;
+}
+
+//#endregion
+//#region src/extraction/resolveExpressionValue.ts
+/**
+* 引数が渡されなかった場合を表す特別な値
+* 必須/任意を問わず、引数未指定の使用箇所を統一的に扱うために使用
+*
+* 注意: この値は文字列 "[undefined]" であり、JavaScriptの undefined とは異なる。
+* 解決関数が undefined を返す場合は「値を解決できなかった」ことを意味し、
+* この文字列を返す場合は「実際に undefined が渡された」ことを意味する。
+*/
+const UNDEFINED_VALUE = "[undefined]";
+/**
+* 関数型の値を表すプレフィックス
+* コールバック関数など、関数が渡された場合は使用箇所ごとにユニークな値として扱う
+* これにより、同じコールバック関数を渡していても「定数」として検出されない
+*/
+const FUNCTION_VALUE_PREFIX = "[function]";
+/**
+* 式の実際の値を解決する
+*
+* 異なるファイルで同じenum値やリテラル値を使用している場合でも、
+* 同一の値として認識できるよう、値を正規化して文字列表現で返す。
+* 同名だが異なる定義（別ファイルの同名enum等）を区別するため、
+* 必要に応じてファイルパスを含めた識別子を返す。
+*
+* @param expression - 解決対象の式
+* @param context - 呼び出し情報などのコンテキスト
+*/
+function resolveExpressionValue(expression, context) {
+	return argValueToString(extractArgValue(expression), context);
+}
+/**
+* ArgValue を文字列表現に変換する
+*
+* @param value - 変換対象の ArgValue
+* @param context - パラメータ参照解決用のコンテキスト
+*/
+function argValueToString(value, context) {
+	switch (value.type) {
+		case ArgValueType.Literal: return value.value;
+		case ArgValueType.Function: return `${FUNCTION_VALUE_PREFIX}${value.filePath}:${value.line}`;
+		case ArgValueType.ParamRef: {
+			const resolved = resolveParameterValue(value, context.callSiteMap);
+			if (resolved !== void 0) return argValueToKey(resolved);
+			return argValueToKey(value);
+		}
+		case ArgValueType.Undefined: return UNDEFINED_VALUE;
+	}
+}
+
+//#endregion
+//#region src/extraction/flattenObjectExpression.ts
+/**
+* オブジェクトリテラルを再帰的に解析し、フラットなkey-valueペアを返す
+*
+* @param expression - 解析対象の式ノード
+* @param prefix - キー名のプレフィックス（ネストしたプロパティの親パスを表す）
+* @param context - 呼び出し情報などのコンテキスト
+* @returns フラット化されたkey-valueペアの配列
+*
+* @example
+* // { a: { b: 1, c: 2 } } → [{ key: "prefix.a.b", value: "1" }, { key: "prefix.a.c", value: "2" }]
+*/
+function flattenObjectExpression(expression, prefix, context) {
+	if (!Node.isObjectLiteralExpression(expression)) return [{
+		key: prefix,
+		value: resolveExpressionValue(expression, context)
+	}];
+	return expression.getProperties().flatMap((property) => {
+		if (Node.isPropertyAssignment(property)) {
+			const propertyName = property.getName();
+			const nestedPrefix = prefix ? `${prefix}.${propertyName}` : propertyName;
+			const initializer = property.getInitializer();
+			return initializer ? flattenObjectExpression(initializer, nestedPrefix, context) : [];
+		}
+		if (Node.isShorthandPropertyAssignment(property)) {
+			const propertyName = property.getName();
+			return [{
+				key: prefix ? `${prefix}.${propertyName}` : propertyName,
+				value: resolveExpressionValue(property.getNameNode(), context)
+			}];
+		}
+		return [];
+	});
+}
+
+//#endregion
+//#region src/extraction/hasDisableComment.ts
+const DISABLE_NEXT_LINE = "dittory-disable-next-line";
+const DISABLE_LINE = "dittory-disable-line";
+/**
+* ノードに除外コメントがあるかを判定する
+*
+* 以下の2パターンをサポート：
+* - "dittory-disable-next-line": 次の行を除外（leading comments をチェック）
+* - "dittory-disable-line": 同じ行を除外（trailing comments をチェック）
+*
+* 祖先ノードを辿り、いずれかのノードのコメントに
+* 除外キーワードが含まれていれば除外対象とする。
+*
+* @param node - 判定対象のノード
+* @returns 除外コメントが存在すれば true
+*/
+function hasDisableComment(node) {
+	let current = node;
+	while (current) {
+		const leadingComments = current.getLeadingCommentRanges();
+		const trailingComments = current.getTrailingCommentRanges();
+		for (const comment of leadingComments) if (comment.getText().includes(DISABLE_NEXT_LINE)) return true;
+		for (const comment of trailingComments) if (comment.getText().includes(DISABLE_LINE)) return true;
+		current = current.getParent();
+	}
+	return false;
+}
+
+//#endregion
+//#region src/extraction/extractUsages.ts
+/**
+* 使用状況を抽出するユーティリティクラス
+*/
+var ExtractUsages = class {
+	/**
+	* 関数呼び出しから引数の使用状況を抽出する
+	*
+	* オブジェクトリテラルの場合は再帰的にフラット化し、
+	* 各プロパティを「引数名.プロパティ名」形式で記録する。
+	*
+	* @param callExpression - 関数呼び出しノード
+	* @param callable - 対象の関数情報
+	* @param context - 呼び出し情報などのコンテキスト
+	* @returns 引数使用状況の配列
+	*/
+	static fromCall(callExpression, callable, context) {
+		if (hasDisableComment(callExpression)) return [];
+		const usages = [];
+		const sourceFile = callExpression.getSourceFile();
+		const args = callExpression.getArguments();
+		for (const param of callable.definitions) {
+			const arg = args[param.index];
+			if (!arg) {
+				usages.push({
+					name: param.name,
+					value: UNDEFINED_VALUE,
+					usageFilePath: sourceFile.getFilePath(),
+					usageLine: callExpression.getStartLineNumber()
+				});
+				continue;
+			}
+			for (const { key, value } of flattenObjectExpression(arg, param.name, context)) usages.push({
+				name: key,
+				value,
+				usageFilePath: sourceFile.getFilePath(),
+				usageLine: arg.getStartLineNumber()
+			});
+		}
+		return usages;
+	}
+	/**
+	* JSX要素からprops使用状況を抽出する
+	*
+	* @param element - JSX要素ノード
+	* @param definitions - props定義の配列
+	* @param context - 呼び出し情報などのコンテキスト
+	* @returns props使用状況の配列
+	*/
+	static fromJsxElement(element, definitions, context) {
+		if (hasDisableComment(element)) return [];
+		const usages = [];
+		const sourceFile = element.getSourceFile();
+		const attributeMap = /* @__PURE__ */ new Map();
+		for (const attr of element.getAttributes()) if (Node.isJsxAttribute(attr)) attributeMap.set(attr.getNameNode().getText(), attr);
+		for (const prop of definitions) {
+			const attr = attributeMap.get(prop.name);
+			if (!attr) {
+				usages.push({
+					name: prop.name,
+					value: UNDEFINED_VALUE,
+					usageFilePath: sourceFile.getFilePath(),
+					usageLine: element.getStartLineNumber()
+				});
+				continue;
+			}
+			const initializer = attr.getInitializer();
+			if (!initializer) usages.push({
+				name: prop.name,
+				value: "true",
+				usageFilePath: sourceFile.getFilePath(),
+				usageLine: attr.getStartLineNumber()
+			});
+			else if (Node.isJsxExpression(initializer)) {
+				const expression = initializer.getExpression();
+				if (!expression) continue;
+				for (const { key, value } of flattenObjectExpression(expression, prop.name, context)) usages.push({
+					name: key,
+					value,
+					usageFilePath: sourceFile.getFilePath(),
+					usageLine: attr.getStartLineNumber()
+				});
+			} else usages.push({
+				name: prop.name,
+				value: initializer.getText(),
+				usageFilePath: sourceFile.getFilePath(),
+				usageLine: attr.getStartLineNumber()
+			});
+		}
+		return usages;
+	}
+};
+
+//#endregion
+//#region src/utils/getSingleValueFromSet.ts
+/**
+* Setから唯一の値を安全に取得する
+*/
+function getSingleValueFromSet(values) {
+	if (values.size !== 1) throw new Error(`Expected exactly 1 value, got ${values.size}`);
+	const [firstValue] = Array.from(values);
+	return firstValue;
+}
+
+//#endregion
+//#region src/analyzer/baseAnalyzer.ts
+/**
+* 分析処理の基底クラス
+*/
+var BaseAnalyzer = class {
+	shouldExcludeFile;
+	minUsages;
+	callSiteMap;
+	constructor(options = {}) {
+		this.shouldExcludeFile = options.shouldExcludeFile ?? isTestOrStorybookFile;
+		this.minUsages = options.minUsages ?? 2;
+	}
+	/**
+	* 呼び出し情報を設定する
+	* パラメータ経由で渡された値を解決するために使用
+	*
+	* @param callSiteMap - 呼び出し情報マップ
+	*/
+	setCallSiteMap(callSiteMap) {
+		this.callSiteMap = callSiteMap;
+	}
+	/**
+	* コンテキストを取得する
+	*/
+	getResolveContext() {
+		return { callSiteMap: this.callSiteMap };
+	}
+	/**
+	* 識別子から全参照を検索し、除外対象ファイルからの参照をフィルタリングする
+	*
+	* @param nameNode - 検索対象の識別子ノード
+	* @returns フィルタリングされた参照エントリの配列
+	*/
+	findFilteredReferences(nameNode) {
+		return nameNode.findReferences().flatMap((referencedSymbol) => referencedSymbol.getReferences()).filter((ref) => !this.shouldExcludeFile(ref.getSourceFile().getFilePath()));
+	}
+	/**
+	* 使用状況をグループに追加する
+	*
+	* @param groupedUsages - 使用状況のグループ（パラメータ名 → 使用状況配列）
+	* @param usages - 追加する使用状況の配列
+	*/
+	addUsagesToGroup(groupedUsages, usages) {
+		for (const usage of usages) {
+			if (!groupedUsages[usage.name]) groupedUsages[usage.name] = [];
+			groupedUsages[usage.name].push(usage);
+		}
+	}
+	/**
+	* ノードからパラメータ定義を取得する
+	*
+	* FunctionDeclaration, MethodDeclaration, VariableDeclaration（ArrowFunction/FunctionExpression）
+	* からパラメータを抽出し、Definition配列として返す。
+	*
+	* @param node - パラメータを抽出する対象のノード
+	* @returns パラメータ定義の配列
+	*/
+	getParameterDefinitions(node) {
+		return this.extractParameterDeclarations(node).map((param, index) => ({
+			name: param.getName(),
+			index,
+			required: !param.hasQuestionToken() && !param.hasInitializer()
+		}));
+	}
+	/**
+	* ノードからParameterDeclarationの配列を抽出する
+	*
+	* 以下のノードタイプに対応:
+	* - FunctionDeclaration: 直接パラメータを取得
+	* - MethodDeclaration: 直接パラメータを取得
+	* - VariableDeclaration: 初期化子がArrowFunctionまたはFunctionExpressionの場合にパラメータを取得
+	*
+	* @param node - パラメータを抽出する対象のノード
+	* @returns ParameterDeclarationの配列
+	*/
+	extractParameterDeclarations(node) {
+		if (Node.isFunctionDeclaration(node)) return node.getParameters();
+		if (Node.isMethodDeclaration(node)) return node.getParameters();
+		if (Node.isVariableDeclaration(node)) {
+			const initializer = node.getInitializer();
+			if (initializer) {
+				if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) return initializer.getParameters();
+			}
+		}
+		return [];
+	}
+	/**
+	* メイン分析処理
+	*
+	* @param declarations - 事前分類済みの宣言配列
+	*/
+	analyze(declarations) {
+		const exported = this.collect(declarations);
+		const groupedMap = this.createGroupedMap(exported);
+		return {
+			constants: this.extractConstants(groupedMap),
+			exported
+		};
+	}
+	/**
+	* 使用状況をグループ化したマップを作成
+	*/
+	createGroupedMap(exported) {
+		const groupedMap = /* @__PURE__ */ new Map();
+		for (const item of exported) {
+			let fileMap = groupedMap.get(item.sourceFilePath);
+			if (!fileMap) {
+				fileMap = /* @__PURE__ */ new Map();
+				groupedMap.set(item.sourceFilePath, fileMap);
+			}
+			const paramMap = /* @__PURE__ */ new Map();
+			for (const [paramName, usages] of Object.entries(item.usages)) {
+				const values = /* @__PURE__ */ new Set();
+				for (const usage of usages) values.add(usage.value);
+				paramMap.set(paramName, {
+					values,
+					usages
+				});
+			}
+			fileMap.set(item.name, {
+				line: item.sourceLine,
+				params: paramMap
+			});
+		}
+		return groupedMap;
+	}
+	/**
+	* 常に同じ値が渡されているパラメータを抽出
+	*/
+	extractConstants(groupedMap) {
+		const result = [];
+		for (const [sourceFile, targetMap] of groupedMap) for (const [targetName, targetInfo] of targetMap) for (const [paramName, usageData] of targetInfo.params) {
+			if (!(usageData.usages.length >= this.minUsages && usageData.values.size === 1)) continue;
+			const value = getSingleValueFromSet(usageData.values);
+			if (value.startsWith(FUNCTION_VALUE_PREFIX)) continue;
+			result.push({
+				targetName,
+				targetSourceFile: sourceFile,
+				targetLine: targetInfo.line,
+				paramName,
+				value,
+				usages: usageData.usages
+			});
+		}
+		return result;
+	}
+};
+
+//#endregion
+//#region src/analyzer/classMethodAnalyzer.ts
+/**
+* クラスメソッドの引数分析を行うAnalyzer
+*
+* exportされたクラスのメソッド（static/instance）を収集し、
+* 各メソッドの引数使用状況を分析する。
+* 常に同じ値が渡されている引数を検出し、定数として報告する。
+*
+* @example
+* ```ts
+* const analyzer = new ClassMethodAnalyzer({ minUsages: 2 });
+* const result = analyzer.analyze(declarations);
+* console.log(result.constants);
+* ```
+*/
+var ClassMethodAnalyzer = class extends BaseAnalyzer {
+	constructor(options = {}) {
+		super(options);
+	}
+	/**
+	* 事前分類済みの宣言からクラスメソッドを収集する
+	*
+	* @param declarations - 事前分類済みの宣言配列（type: "class"）
+	* @returns クラスメソッドとその使用状況の配列（名前は「ClassName.methodName」形式）
+	*/
+	collect(declarations) {
+		const results = [];
+		for (const classified of declarations) {
+			const { exportName, sourceFile, declaration } = classified;
+			if (!Node.isClassDeclaration(declaration)) continue;
+			const methods = declaration.getMethods();
+			for (const method of methods) {
+				const methodName = method.getName();
+				const parameters = this.getParameterDefinitions(method);
+				const callable = {
+					name: `${exportName}.${methodName}`,
+					sourceFilePath: sourceFile.getFilePath(),
+					sourceLine: method.getStartLineNumber(),
+					definitions: parameters,
+					declaration: method,
+					usages: {}
+				};
+				const nameNode = method.getNameNode();
+				if (!Node.isIdentifier(nameNode)) continue;
+				const references = this.findFilteredReferences(nameNode);
+				const groupedUsages = {};
+				for (const reference of references) {
+					const propertyAccess = reference.getNode().getParent();
+					if (!propertyAccess || !Node.isPropertyAccessExpression(propertyAccess)) continue;
+					const callExpression = propertyAccess.getParent();
+					if (!callExpression || !Node.isCallExpression(callExpression)) continue;
+					if (callExpression.getExpression() !== propertyAccess) continue;
+					const usages = ExtractUsages.fromCall(callExpression, callable, this.getResolveContext());
+					this.addUsagesToGroup(groupedUsages, usages);
+				}
+				callable.usages = groupedUsages;
+				results.push(callable);
+			}
+		}
+		return results;
+	}
+};
+
+//#endregion
+//#region src/analyzer/functionAnalyzer.ts
+/**
+* 関数の引数分析を行うAnalyzer
+*
+* exportされた関数を収集し、各関数の引数使用状況を分析する。
+* 常に同じ値が渡されている引数を検出し、定数として報告する。
+*
+* @example
+* ```ts
+* const analyzer = new FunctionAnalyzer({ minUsages: 2 });
+* const result = analyzer.analyze(declarations);
+* console.log(result.constants);
+* ```
+*/
+var FunctionAnalyzer = class extends BaseAnalyzer {
+	constructor(options = {}) {
+		super(options);
+	}
+	/**
+	* 事前分類済みの宣言から関数を収集する
+	*
+	* @param declarations - 事前分類済みの宣言配列（type: "function"）
+	* @returns exportされた関数とその使用状況の配列
+	*/
+	collect(declarations) {
+		const results = [];
+		for (const classified of declarations) {
+			const { exportName, sourceFile, declaration } = classified;
+			if (!Node.isFunctionDeclaration(declaration) && !Node.isVariableDeclaration(declaration)) continue;
+			const nameNode = declaration.getNameNode();
+			if (!nameNode || !Node.isIdentifier(nameNode)) continue;
+			const references = this.findFilteredReferences(nameNode);
+			const parameters = this.getParameterDefinitions(declaration);
+			const callable = {
+				name: exportName,
+				sourceFilePath: sourceFile.getFilePath(),
+				sourceLine: declaration.getStartLineNumber(),
+				definitions: parameters,
+				declaration,
+				usages: {}
+			};
+			const groupedUsages = {};
+			for (const reference of references) {
+				const refNode = reference.getNode();
+				const parent = refNode.getParent();
+				if (!parent) continue;
+				const callExpression = parent.asKind(SyntaxKind.CallExpression);
+				if (!callExpression) continue;
+				if (callExpression.getExpression() !== refNode) continue;
+				const usages = ExtractUsages.fromCall(callExpression, callable, this.getResolveContext());
+				this.addUsagesToGroup(groupedUsages, usages);
+			}
+			callable.usages = groupedUsages;
+			results.push(callable);
+		}
+		return results;
+	}
+};
+
+//#endregion
+//#region src/components/isReactComponent.ts
+/**
+* 宣言がReactコンポーネントかどうかを判定する
+* - 関数がJSXを返しているかチェック
+* - React.FC型注釈を持っているかチェック
+*/
+function isReactComponent(declaration) {
+	if (Node.isFunctionDeclaration(declaration)) return containsJsx(declaration);
+	if (Node.isVariableDeclaration(declaration)) {
+		const initializer = declaration.getInitializer();
+		if (!initializer) return false;
+		if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) return containsJsx(initializer);
+		if (Node.isCallExpression(initializer)) {
+			const args = initializer.getArguments();
+			for (const arg of args) if (Node.isArrowFunction(arg) || Node.isFunctionExpression(arg)) {
+				if (containsJsx(arg)) return true;
+			}
+		}
+	}
+	return false;
+}
+/**
+* ノード内にJSX要素が含まれているかチェック
+* 効率化: 1回のトラバースで全てのJSX要素をチェック
+*/
+function containsJsx(node) {
+	let hasJsx = false;
+	node.forEachDescendant((descendant) => {
+		if (Node.isJsxElement(descendant) || Node.isJsxSelfClosingElement(descendant) || Node.isJsxFragment(descendant)) {
+			hasJsx = true;
+			return true;
+		}
+	});
+	return hasJsx;
+}
+
+//#endregion
+//#region src/source/classifyDeclarations.ts
+/**
+* ソースファイルからexportされた関数/コンポーネント/クラス宣言を収集し、
+* 種別（react/function/class）を事前に分類する
+*
+* @param sourceFiles - 分析対象のソースファイル配列
+* @returns 分類済みの宣言配列
+*/
+function classifyDeclarations(sourceFiles) {
+	const results = [];
+	for (const sourceFile of sourceFiles) {
+		const exportedDecls = sourceFile.getExportedDeclarations();
+		for (const [exportName, declarations] of exportedDecls) {
+			const funcDecl = declarations.find((decl) => isFunctionLike(decl));
+			if (funcDecl) {
+				if (Node.isFunctionDeclaration(funcDecl) || Node.isVariableDeclaration(funcDecl)) {
+					const type = isReactComponent(funcDecl) ? "react" : "function";
+					results.push({
+						exportName,
+						sourceFile,
+						declaration: funcDecl,
+						type
+					});
+				}
+				continue;
+			}
+			const classDecl = declarations.find((decl) => Node.isClassDeclaration(decl));
+			if (classDecl && Node.isClassDeclaration(classDecl)) results.push({
+				exportName,
+				sourceFile,
+				declaration: classDecl,
+				type: "class"
+			});
+		}
+	}
+	return results;
+}
+/**
+* 宣言が関数的なもの（関数宣言、アロー関数、関数式）かどうかを判定
+*/
+function isFunctionLike(declaration) {
+	if (Node.isFunctionDeclaration(declaration)) return true;
+	if (Node.isVariableDeclaration(declaration)) {
+		const initializer = declaration.getInitializer();
+		if (!initializer) return false;
+		return Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer) || Node.isCallExpression(initializer);
+	}
+	return false;
+}
+
+//#endregion
+//#region src/analyzeFunctions.ts
+/**
+* 関数・クラスメソッドの引数使用状況を解析し、常に同じ値が渡されている引数を検出する
+*
+* @param sourceFiles - 解析対象のソースファイル配列
+* @param options - オプション設定
+* @returns 解析結果（定数引数、統計情報、exportされた関数・メソッド）
+*
+* @example
+* const project = new Project();
+* project.addSourceFilesAtPaths("src/**\/*.ts");
+* const result = analyzeFunctionsCore(project.getSourceFiles());
+*/
+function analyzeFunctionsCore(sourceFiles, options) {
+	const { shouldExcludeFile = isTestOrStorybookFile, minUsages = 2, callSiteMap } = options;
+	const declarations = classifyDeclarations(sourceFiles);
+	const functions = declarations.filter((decl) => decl.type === "function");
+	const classes = declarations.filter((decl) => decl.type === "class");
+	const analyzerOptions = {
+		shouldExcludeFile,
+		minUsages
+	};
+	const functionAnalyzer = new FunctionAnalyzer(analyzerOptions);
+	functionAnalyzer.setCallSiteMap(callSiteMap);
+	const functionResult = functionAnalyzer.analyze(functions);
+	const classMethodAnalyzer = new ClassMethodAnalyzer(analyzerOptions);
+	classMethodAnalyzer.setCallSiteMap(callSiteMap);
+	const classMethodResult = classMethodAnalyzer.analyze(classes);
+	return {
+		constants: [...functionResult.constants, ...classMethodResult.constants],
+		exported: [...functionResult.exported, ...classMethodResult.exported]
+	};
+}
+
+//#endregion
+//#region src/components/getProps.ts
+/**
+* コンポーネントのprops定義を取得する
+*
+* 関数の第一パラメータの型情報からpropsを抽出する。
+* 「Props」などの命名規則に依存せず、TypeScriptの型システムから直接取得するため、
+* どのような命名でもpropsを正確に取得できる。
+*
+* 対応パターン:
+* - function Component(props: Props)
+* - const Component = (props: Props) => ...
+* - React.forwardRef((props, ref) => ...)
+* - React.memo((props) => ...)
+*/
+function getProps(declaration) {
+	let propsParam;
+	if (Node.isFunctionDeclaration(declaration)) {
+		const params = declaration.getParameters();
+		if (params.length > 0) propsParam = params[0];
+	} else if (Node.isVariableDeclaration(declaration)) {
+		const initializer = declaration.getInitializer();
+		if (initializer) {
+			if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) {
+				const params = initializer.getParameters();
+				if (params.length > 0) propsParam = params[0];
+			} else if (Node.isCallExpression(initializer)) {
+				const args = initializer.getArguments();
+				for (const arg of args) if (Node.isArrowFunction(arg) || Node.isFunctionExpression(arg)) {
+					const params = arg.getParameters();
+					if (params.length > 0) {
+						propsParam = params[0];
+						break;
+					}
+				}
+			}
+		}
+	}
+	if (!propsParam) return [];
+	return extractPropsFromType(propsParam.getType());
+}
+/**
+* 型からprops定義を抽出する
+*
+* Mapを使用する理由:
+* - 交差型（A & B）の場合、同じprop名が複数の型に存在する可能性がある
+* - 最初に見つかった定義を優先し、重複を排除するためにMapを使用
+* - 抽出後にindexを付与してDefinition配列として返す
+*/
+function extractPropsFromType(type) {
+	const propsMap = /* @__PURE__ */ new Map();
+	collectPropsFromType(type, propsMap);
+	return Array.from(propsMap.values()).map((prop, index) => ({
+		...prop,
+		index
+	}));
+}
+/**
+* 型からpropsを収集する（交差型の場合は再帰的に処理）
+*/
+function collectPropsFromType(type, propsMap) {
+	if (type.isIntersection()) {
+		for (const intersectionType of type.getIntersectionTypes()) collectPropsFromType(intersectionType, propsMap);
+		return;
+	}
+	const properties = type.getProperties();
+	for (const prop of properties) {
+		const propName = prop.getName();
+		const declarations = prop.getDeclarations();
+		let isOptional = false;
+		for (const decl of declarations) if (Node.isPropertySignature(decl) && decl.hasQuestionToken()) {
+			isOptional = true;
+			break;
+		}
+		if (!propsMap.has(propName)) propsMap.set(propName, {
+			name: propName,
+			required: !isOptional
+		});
+	}
+}
+
+//#endregion
+//#region src/analyzer/componentAnalyzer.ts
+/**
+* Reactコンポーネントのprops分析を行うAnalyzer
+*
+* exportされたReactコンポーネントを収集し、各コンポーネントのprops使用状況を分析する。
+* 常に同じ値が渡されているpropsを検出し、定数として報告する。
+*
+* @example
+* ```ts
+* const analyzer = new ComponentAnalyzer({ minUsages: 2 });
+* const result = analyzer.analyze(sourceFiles);
+* console.log(result.constants);
+* ```
+*/
+var ComponentAnalyzer = class extends BaseAnalyzer {
+	constructor(options = {}) {
+		super(options);
+	}
+	/**
+	* 事前分類済みの宣言からReactコンポーネントを収集する
+	*
+	* @param declarations - 事前分類済みの宣言配列
+	* @returns exportされたコンポーネントとその使用状況の配列
+	*/
+	collect(declarations) {
+		const exportedComponents = [];
+		for (const classified of declarations) {
+			const { exportName, sourceFile, declaration } = classified;
+			if (!Node.isFunctionDeclaration(declaration) && !Node.isVariableDeclaration(declaration)) continue;
+			const nameNode = declaration.getNameNode();
+			if (!nameNode || !Node.isIdentifier(nameNode)) continue;
+			const references = this.findFilteredReferences(nameNode);
+			const props = getProps(declaration);
+			const component = {
+				name: exportName,
+				sourceFilePath: sourceFile.getFilePath(),
+				sourceLine: declaration.getStartLineNumber(),
+				definitions: props,
+				declaration,
+				usages: {}
+			};
+			const groupedUsages = {};
+			for (const reference of references) {
+				const refNode = reference.getNode();
+				const parent = refNode.getParent();
+				if (!parent) continue;
+				const jsxElement = parent.asKind(SyntaxKind.JsxOpeningElement) ?? parent.asKind(SyntaxKind.JsxSelfClosingElement);
+				if (!jsxElement) continue;
+				if (jsxElement.getTagNameNode() !== refNode) continue;
+				const usages = ExtractUsages.fromJsxElement(jsxElement, component.definitions, this.getResolveContext());
+				this.addUsagesToGroup(groupedUsages, usages);
+			}
+			component.usages = groupedUsages;
+			exportedComponents.push(component);
+		}
+		return exportedComponents;
+	}
+};
+
+//#endregion
+//#region src/analyzeProps.ts
+/**
+* コンポーネントのprops使用状況を解析し、常に同じ値が渡されているpropsを検出する
+*
+* @param sourceFiles - 解析対象のソースファイル配列
+* @param options - オプション設定
+* @returns 解析結果（定数props、統計情報、exportされたコンポーネント）
+*
+* @example
+* const project = new Project();
+* project.addSourceFilesAtPaths("src/**\/*.tsx");
+* const result = analyzePropsCore(project.getSourceFiles());
+*/
+function analyzePropsCore(sourceFiles, options) {
+	const { shouldExcludeFile = isTestOrStorybookFile, minUsages = 2, callSiteMap } = options;
+	const components = classifyDeclarations(sourceFiles).filter((decl) => decl.type === "react");
+	const analyzer = new ComponentAnalyzer({
+		shouldExcludeFile,
+		minUsages
+	});
+	analyzer.setCallSiteMap(callSiteMap);
+	return analyzer.analyze(components);
+}
+
+//#endregion
+export { isTestOrStorybookFile as i, analyzeFunctionsCore as n, collectCallSites as r, analyzePropsCore as t };
+//# sourceMappingURL=analyzeProps-B0TjCZhP.mjs.map