dittory 0.0.3 → 0.0.5

package/dist/callSiteCollector-CGFPm0in.mjs

@@ -0,0 +1,1650 @@
+import { Node, SyntaxKind } from "ts-morph";
+
+//#region src/domain/analyzedDeclarations.ts
+/**
+* 分析対象のコレクション
+*/
+var AnalyzedDeclarations = class AnalyzedDeclarations {
+	items;
+	constructor(items = []) {
+		this.items = items;
+	}
+	/**
+	* 複数の AnalyzedDeclarations を結合して新しい AnalyzedDeclarations を作成
+	*/
+	static merge(...declarationsArray) {
+		const merged = [];
+		for (const declarations of declarationsArray) merged.push(...declarations.items);
+		return new AnalyzedDeclarations(merged);
+	}
+	/**
+	* 分析対象が存在しないかどうか
+	*/
+	isEmpty() {
+		return this.items.length === 0;
+	}
+	/**
+	* 分析対象の件数
+	*/
+	get length() {
+		return this.items.length;
+	}
+	/**
+	* 分析対象を追加
+	*/
+	push(item) {
+		this.items.push(item);
+	}
+	/**
+	* 各要素に対して関数を適用し、結果の配列を返す
+	*/
+	map(callback) {
+		return this.items.map(callback);
+	}
+	/**
+	* 条件に一致する最初の要素を返す
+	*/
+	find(predicate) {
+		return this.items.find(predicate);
+	}
+	/**
+	* インデックスで要素を取得
+	*/
+	get(index) {
+		return this.items[index];
+	}
+	/**
+	* イテレーション用
+	*/
+	*[Symbol.iterator]() {
+		yield* this.items;
+	}
+};
+
+//#endregion
+//#region src/domain/usagesByParam.ts
+/**
+* パラメータ名ごとにUsageをグループ化して管理するクラス
+*/
+var UsagesByParam = class extends Map {
+	/**
+	* Usageを追加する
+	*/
+	add(usage) {
+		const usages = this.get(usage.name) ?? [];
+		usages.push(usage);
+		this.set(usage.name, usages);
+	}
+	/**
+	* 複数のUsageを追加する
+	*/
+	addAll(usages) {
+		for (const usage of usages) this.add(usage);
+	}
+};
+
+//#endregion
+//#region src/domain/argValueClasses.ts
+/**
+* 引数の値を表す基底抽象クラス
+*/
+var ArgValue = class {
+	/**
+	* 比較可能な文字列キーに変換する
+	* 同じ値かどうかの判定に使用
+	*/
+	toKey() {
+		return `[${this.prefix}]${this.getValue()}`;
+	}
+	/**
+	* 出力用の文字列表現を取得する
+	*/
+	outputString() {
+		if (this.includePrefixInOutput) return `[${this.prefix}]${this.getValue()}`;
+		return this.getValue();
+	}
+};
+/**
+* リテラル値の基底抽象クラス
+* 出力時はプレフィックスなし、比較キーには [literal] プレフィックスを付ける
+*/
+var LiteralArgValue = class extends ArgValue {
+	prefix = "literal";
+	includePrefixInOutput = false;
+};
+/**
+* enum メンバーのリテラル値
+*/
+var EnumLiteralArgValue = class extends LiteralArgValue {
+	constructor(filePath, enumName, memberName, enumValue) {
+		super();
+		this.filePath = filePath;
+		this.enumName = enumName;
+		this.memberName = memberName;
+		this.enumValue = enumValue;
+	}
+	getValue() {
+		return `${this.filePath}:${this.enumName}.${this.memberName}=${JSON.stringify(this.enumValue)}`;
+	}
+	outputString() {
+		return `${this.enumName}.${this.memberName}`;
+	}
+};
+/**
+* this プロパティアクセスのリテラル値
+*/
+var ThisLiteralArgValue = class extends LiteralArgValue {
+	constructor(filePath, line, expression) {
+		super();
+		this.filePath = filePath;
+		this.line = line;
+		this.expression = expression;
+	}
+	prefix = "this";
+	includePrefixInOutput = true;
+	getValue() {
+		return `${this.filePath}:${this.line}:${this.expression}`;
+	}
+};
+/**
+* メソッド呼び出しのリテラル値
+*/
+var MethodCallLiteralArgValue = class extends LiteralArgValue {
+	constructor(filePath, line, expression) {
+		super();
+		this.filePath = filePath;
+		this.line = line;
+		this.expression = expression;
+	}
+	prefix = "methodCall";
+	includePrefixInOutput = true;
+	getValue() {
+		return `${this.filePath}:${this.line}:${this.expression}`;
+	}
+};
+/**
+* 変数参照のリテラル値
+*/
+var VariableLiteralArgValue = class extends LiteralArgValue {
+	constructor(filePath, identifier, declarationLine) {
+		super();
+		this.filePath = filePath;
+		this.identifier = identifier;
+		this.declarationLine = declarationLine;
+	}
+	getValue() {
+		return `${this.filePath}:${this.declarationLine}:${this.identifier}`;
+	}
+};
+/**
+* boolean リテラル値
+*/
+var BooleanLiteralArgValue = class extends LiteralArgValue {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	getValue() {
+		return String(this.value);
+	}
+};
+/**
+* 文字列リテラル値
+*/
+var StringLiteralArgValue = class extends LiteralArgValue {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	getValue() {
+		return JSON.stringify(this.value);
+	}
+};
+/**
+* 数値リテラル値
+*/
+var NumberLiteralArgValue = class extends LiteralArgValue {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	getValue() {
+		return JSON.stringify(this.value);
+	}
+};
+/**
+* JSX boolean shorthand のリテラル値
+*/
+var JsxShorthandLiteralArgValue = class extends LiteralArgValue {
+	getValue() {
+		return "true";
+	}
+};
+/**
+* その他のリテラル値（フォールバック）
+*/
+var OtherLiteralArgValue = class extends LiteralArgValue {
+	constructor(expression) {
+		super();
+		this.expression = expression;
+	}
+	getValue() {
+		return this.expression;
+	}
+};
+/**
+* 関数型の値
+*/
+var FunctionArgValue = class extends ArgValue {
+	constructor(filePath, line) {
+		super();
+		this.filePath = filePath;
+		this.line = line;
+	}
+	prefix = "function";
+	includePrefixInOutput = true;
+	getValue() {
+		return `${this.filePath}:${this.line}`;
+	}
+};
+/**
+* パラメータ参照の値
+*/
+var ParamRefArgValue = class extends ArgValue {
+	constructor(filePath, functionName, path, line) {
+		super();
+		this.filePath = filePath;
+		this.functionName = functionName;
+		this.path = path;
+		this.line = line;
+	}
+	prefix = "paramRef";
+	includePrefixInOutput = true;
+	getValue() {
+		return `${this.filePath}:${this.functionName}:${this.path}`;
+	}
+};
+/**
+* undefined の値
+*/
+var UndefinedArgValue = class extends ArgValue {
+	prefix = "undefined";
+	includePrefixInOutput = true;
+	getValue() {
+		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 declaration - 分析対象の関数情報
+	* @param resolver - 式を解決するためのリゾルバ
+	* @returns 引数使用状況の配列
+	*/
+	static fromCall(callExpression, declaration, resolver) {
+		if (hasDisableComment(callExpression)) return [];
+		const usages = [];
+		const sourceFile = callExpression.getSourceFile();
+		const args = callExpression.getArguments();
+		for (const definition of declaration.definitions) {
+			const arg = args[definition.index];
+			if (!arg) {
+				usages.push({
+					name: definition.name,
+					value: new UndefinedArgValue(),
+					usageFilePath: sourceFile.getFilePath(),
+					usageLine: callExpression.getStartLineNumber()
+				});
+				continue;
+			}
+			for (const { key, value } of resolver.flattenObject(arg, definition.name)) usages.push({
+				name: key,
+				value,
+				usageFilePath: sourceFile.getFilePath(),
+				usageLine: arg.getStartLineNumber()
+			});
+		}
+		return usages;
+	}
+	/**
+	* JSX要素からprops使用状況を抽出する
+	*
+	* @param element - JSX要素ノード
+	* @param definitions - props定義の配列
+	* @param resolver - 式を解決するためのリゾルバ
+	* @returns props使用状況の配列
+	*/
+	static fromJsxElement(element, definitions, resolver) {
+		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 definition of definitions) {
+			const attr = attributeMap.get(definition.name);
+			if (!attr) {
+				usages.push({
+					name: definition.name,
+					value: new UndefinedArgValue(),
+					usageFilePath: sourceFile.getFilePath(),
+					usageLine: element.getStartLineNumber()
+				});
+				continue;
+			}
+			const initializer = attr.getInitializer();
+			if (!initializer) usages.push({
+				name: definition.name,
+				value: new JsxShorthandLiteralArgValue(),
+				usageFilePath: sourceFile.getFilePath(),
+				usageLine: attr.getStartLineNumber()
+			});
+			else if (Node.isJsxExpression(initializer)) {
+				const expression = initializer.getExpression();
+				if (!expression) continue;
+				for (const { key, value } of resolver.flattenObject(expression, definition.name)) usages.push({
+					name: key,
+					value,
+					usageFilePath: sourceFile.getFilePath(),
+					usageLine: attr.getStartLineNumber()
+				});
+			} else usages.push({
+				name: definition.name,
+				value: resolver.resolve(initializer),
+				usageFilePath: sourceFile.getFilePath(),
+				usageLine: attr.getStartLineNumber()
+			});
+		}
+		return usages;
+	}
+};
+
+//#endregion
+//#region src/domain/constantCandidate.ts
+/**
+* 定数候補
+*
+* あるパラメータに渡された値を集約し、定数として扱えるかを判定する
+*/
+var ConstantCandidate = class {
+	/** 値の比較キー（toKey()の結果）のセット */
+	valueKeys;
+	/** 代表的な値（定数検出時に使用） */
+	representativeValue;
+	usages;
+	constructor(usages) {
+		this.usages = usages;
+		this.valueKeys = /* @__PURE__ */ new Set();
+		let representativeValue = new UndefinedArgValue();
+		for (const usage of usages) {
+			this.valueKeys.add(usage.value.toKey());
+			representativeValue = usage.value;
+		}
+		this.representativeValue = representativeValue;
+	}
+	/**
+	* 定数として認識できるかを判定
+	*
+	* 条件:
+	* 1. 使用回数が最小使用回数以上
+	* 2. すべての使用箇所で同じ値（valueKeys.size === 1）
+	* 3. Usage数が総呼び出し回数と一致（すべての呼び出しで値が存在）
+	*    これにより、オプショナルなプロパティが一部の呼び出しでのみ
+	*    指定されている場合を定数として誤検出しない
+	*/
+	isConstant(minUsages, totalCallCount) {
+		return this.usages.length >= minUsages && this.valueKeys.size === 1 && this.usages.length === totalCallCount;
+	}
+};
+
+//#endregion
+//#region src/domain/constantParams.ts
+/**
+* 定数パラメータのコレクション
+*/
+var ConstantParams = class ConstantParams {
+	items;
+	constructor(items = []) {
+		this.items = items;
+	}
+	/**
+	* 複数の ConstantParams を結合して新しい ConstantParams を作成
+	*/
+	static merge(...paramsArray) {
+		const merged = [];
+		for (const params of paramsArray) merged.push(...params.items);
+		return new ConstantParams(merged);
+	}
+	/**
+	* 定数パラメータが存在しないかどうか
+	*/
+	isEmpty() {
+		return this.items.length === 0;
+	}
+	/**
+	* 定数パラメータの件数
+	*/
+	get length() {
+		return this.items.length;
+	}
+	/**
+	* 定数パラメータを追加
+	*/
+	push(item) {
+		this.items.push(item);
+	}
+	/**
+	* 条件に一致する最初の定数パラメータを返す
+	*/
+	find(predicate) {
+		return this.items.find(predicate);
+	}
+	/**
+	* 宣言（関数/コンポーネント）ごとにグループ化
+	*/
+	groupByDeclaration() {
+		const groupMap = /* @__PURE__ */ new Map();
+		for (const constantParam of this.items) {
+			const key = `${constantParam.declarationSourceFile}:${constantParam.declarationName}`;
+			let constantParamGroup = groupMap.get(key);
+			if (!constantParamGroup) {
+				constantParamGroup = {
+					declarationName: constantParam.declarationName,
+					declarationSourceFile: constantParam.declarationSourceFile,
+					declarationLine: constantParam.declarationLine,
+					params: []
+				};
+				groupMap.set(key, constantParamGroup);
+			}
+			constantParamGroup.params.push({
+				paramName: constantParam.paramName,
+				value: constantParam.value,
+				usageCount: constantParam.usages.length,
+				usages: constantParam.usages
+			});
+		}
+		return Array.from(groupMap.values());
+	}
+	/**
+	* イテレーション用
+	*/
+	*[Symbol.iterator]() {
+		yield* this.items;
+	}
+};
+
+//#endregion
+//#region src/extraction/parameterUtils.ts
+/**
+* 式がパラメータ（関数の引数）を参照しているかどうかを判定する
+* ネストしたプロパティアクセス（例: props.nested.value）にも対応
+*/
+function isParameterReference(expression) {
+	if (Node.isIdentifier(expression)) {
+		const declaration = expression.getSymbol()?.getDeclarations()[0];
+		if (!declaration) return false;
+		const kind = declaration.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 new OtherLiteralArgValue(expression.getText());
+	return new ParamRefArgValue(filePath, getFunctionName(functionScope), buildParameterPath(expression), expression.getStartLineNumber());
+}
+
+//#endregion
+//#region src/extraction/extractArgValue.ts
+/**
+* 式がthisキーワードへのプロパティアクセスかどうかを判定する
+* ネストしたアクセス（例: this.logger.name）にも対応
+*/
+function isThisPropertyAccess(expression) {
+	if (Node.isPropertyAccessExpression(expression)) {
+		const baseExpr = expression.getExpression();
+		if (baseExpr.getKind() === SyntaxKind.ThisKeyword) return true;
+		return isThisPropertyAccess(baseExpr);
+	}
+	return false;
+}
+/**
+* 式から ArgValue を抽出する
+*
+* 式の値を型安全な ArgValue として返す。
+* 呼び出し情報収集時および式の値解決時に使用する。
+*
+* @param expression - 解析対象の式ノード（undefinedの場合はUndefinedArgValueを返す）
+* @returns 式の値を表す ArgValue
+*/
+function extractArgValue(expression) {
+	if (!expression) return new UndefinedArgValue();
+	if (Node.isJsxAttribute(expression)) {
+		const initializer = expression.getInitializer();
+		if (!initializer) return new JsxShorthandLiteralArgValue();
+		if (Node.isJsxExpression(initializer)) return extractArgValue(initializer.getExpression());
+		if (Node.isStringLiteral(initializer)) return new StringLiteralArgValue(initializer.getLiteralValue());
+		return new OtherLiteralArgValue(initializer.getText());
+	}
+	const type = expression.getType();
+	if (type.getCallSignatures().length > 0) {
+		const sourceFile = expression.getSourceFile();
+		const line = expression.getStartLineNumber();
+		return new FunctionArgValue(sourceFile.getFilePath(), line);
+	}
+	if (Node.isPropertyAccessExpression(expression)) {
+		const declaration = expression.getSymbol()?.getDeclarations()[0];
+		if (declaration && Node.isEnumMember(declaration)) {
+			const enumDeclaration = declaration.getParent();
+			if (Node.isEnumDeclaration(enumDeclaration)) return new EnumLiteralArgValue(enumDeclaration.getSourceFile().getFilePath(), enumDeclaration.getName(), declaration.getName(), declaration.getValue());
+		}
+		if (isParameterReference(expression.getExpression())) return createParamRefValue(expression);
+		if (isThisPropertyAccess(expression)) return new ThisLiteralArgValue(expression.getSourceFile().getFilePath(), expression.getStartLineNumber(), expression.getText());
+	}
+	if (Node.isIdentifier(expression)) {
+		if (expression.getText() === "undefined") return new UndefinedArgValue();
+		const symbol = expression.getSymbol();
+		const declaration = (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations()[0];
+		if (declaration) {
+			let actualDeclaration = declaration;
+			let kind = declaration.getKind();
+			if (kind === SyntaxKind.ShorthandPropertyAssignment) {
+				const definitions = expression.getDefinitions();
+				for (const def of definitions) {
+					const node = def.getDeclarationNode();
+					if (!node) continue;
+					const k = node.getKind();
+					if (k === SyntaxKind.BindingElement || k === SyntaxKind.Parameter || k === SyntaxKind.VariableDeclaration) {
+						actualDeclaration = node;
+						kind = k;
+						break;
+					}
+				}
+			}
+			if (kind === SyntaxKind.Parameter || kind === SyntaxKind.BindingElement) return createParamRefValue(expression);
+			if (Node.isVariableDeclaration(actualDeclaration)) {
+				const initializer = actualDeclaration.getInitializer();
+				if (initializer) return extractArgValue(initializer);
+				return new VariableLiteralArgValue(actualDeclaration.getSourceFile().getFilePath(), expression.getText(), actualDeclaration.getStartLineNumber());
+			}
+			return new VariableLiteralArgValue(actualDeclaration.getSourceFile().getFilePath(), expression.getText(), actualDeclaration.getStartLineNumber());
+		}
+	}
+	const literalValue = type.getLiteralValue();
+	if (type.isStringLiteral() && typeof literalValue === "string") return new StringLiteralArgValue(literalValue);
+	if (type.isNumberLiteral() && typeof literalValue === "number") return new NumberLiteralArgValue(literalValue);
+	if (type.isBooleanLiteral()) return new BooleanLiteralArgValue(type.getText() === "true");
+	if (Node.isCallExpression(expression)) {
+		const calleeExpr = expression.getExpression();
+		const hasParamRefArg = expression.getArguments().some((arg) => isParameterReference(arg));
+		if (Node.isPropertyAccessExpression(calleeExpr) || hasParamRefArg) return new MethodCallLiteralArgValue(expression.getSourceFile().getFilePath(), expression.getStartLineNumber(), expression.getText());
+	}
+	return new OtherLiteralArgValue(expression.getText());
+}
+
+//#endregion
+//#region src/extraction/extractObjectType.ts
+/**
+* 型からオブジェクト部分を抽出する
+* ユニオン型（例: `{ a: number } | undefined`）から `undefined` を除外して
+* オブジェクト型部分を返す。オブジェクト型でない場合は null を返す。
+*/
+function extractObjectType(type) {
+	if (type.isUnion()) {
+		for (const unionType of type.getUnionTypes()) {
+			if (unionType.isUndefined() || unionType.isNull()) continue;
+			const objType = extractObjectType(unionType);
+			if (objType) return objType;
+		}
+		return null;
+	}
+	if (type.isString() || type.isNumber() || type.isBoolean() || type.isUndefined() || type.isNull() || type.isLiteral()) return null;
+	if (type.isArray()) return null;
+	if (type.isObject() && type.getProperties().length > 0) return type;
+	return null;
+}
+
+//#endregion
+//#region src/extraction/expressionResolver.ts
+/**
+* 式の値を解決するクラス
+* CallSiteMap を使ってパラメータ参照を解決し、ArgValueを返す
+*/
+var ExpressionResolver = class {
+	constructor(callSiteMap) {
+		this.callSiteMap = callSiteMap;
+	}
+	/**
+	* 式の実際の値を解決する
+	*
+	* 異なるファイルで同じenum値やリテラル値を使用している場合でも、
+	* 同一の値として認識できるよう、ArgValueとして返す。
+	* パラメータ参照の場合はcallSiteMapを使って解決を試みる。
+	*/
+	resolve(expression) {
+		const argValue = extractArgValue(expression);
+		if (argValue instanceof ParamRefArgValue) return this.callSiteMap.resolveParamRef(argValue);
+		return argValue;
+	}
+	/**
+	* オブジェクトリテラルを再帰的に解析し、フラットなkey-valueペアを返す
+	*
+	* 期待される型（コンテキスト型）から省略されたプロパティも検出し、
+	* [undefined] として記録する。
+	*
+	* @param expression - 解析対象の式ノード
+	* @param prefix - キー名のプレフィックス（ネストしたプロパティの親パスを表す）
+	* @returns フラット化されたkey-valueペアの配列
+	*
+	* @example
+	* // { a: { b: 1, c: 2 } } → [{ key: "prefix.a.b", value: "1" }, { key: "prefix.a.c", value: "2" }]
+	*/
+	flattenObject(expression, prefix) {
+		if (!Node.isObjectLiteralExpression(expression)) return [{
+			key: prefix,
+			value: this.resolve(expression)
+		}];
+		const existingValues = this.flattenExistingProperties(expression, prefix);
+		const contextualType = expression.getContextualType();
+		const objectType = contextualType ? extractObjectType(contextualType) : null;
+		const missingValues = objectType ? getMissingProperties(expression, objectType, prefix) : [];
+		return [...existingValues, ...missingValues];
+	}
+	/**
+	* オブジェクトリテラル内の既存プロパティをフラット化する
+	*/
+	flattenExistingProperties(expression, prefix) {
+		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 ? this.flattenObject(initializer, nestedPrefix) : [];
+			}
+			if (Node.isShorthandPropertyAssignment(property)) {
+				const propertyName = property.getName();
+				return [{
+					key: prefix ? `${prefix}.${propertyName}` : propertyName,
+					value: this.resolve(property.getNameNode())
+				}];
+			}
+			return [];
+		});
+	}
+};
+/**
+* 期待される型と比較して、省略されたプロパティを検出する
+*
+* 省略されたプロパティがオブジェクト型の場合、そのネストプロパティも
+* 再帰的に UndefinedArgValue として出力する。これにより、親プロパティが
+* 省略された場合でも、ネストプロパティが他の呼び出しと比較可能になる。
+*/
+function getMissingProperties(objectExpression, expectedType, prefix) {
+	const existingPropNames = /* @__PURE__ */ new Set();
+	for (const property of objectExpression.getProperties()) if (Node.isPropertyAssignment(property)) existingPropNames.add(property.getName());
+	else if (Node.isShorthandPropertyAssignment(property)) existingPropNames.add(property.getName());
+	const missingValues = [];
+	for (const propSymbol of expectedType.getProperties()) {
+		const propName = propSymbol.getName();
+		if (existingPropNames.has(propName)) continue;
+		const nestedPrefix = prefix ? `${prefix}.${propName}` : propName;
+		missingValues.push({
+			key: nestedPrefix,
+			value: new UndefinedArgValue()
+		});
+		const propType = propSymbol.getValueDeclaration()?.getType();
+		if (propType) {
+			const objType = extractObjectType(propType);
+			if (objType) missingValues.push(...getNestedMissingProperties(objType, nestedPrefix));
+		}
+	}
+	return missingValues;
+}
+/**
+* 省略された親プロパティのネストプロパティを再帰的に UndefinedArgValue として出力
+*/
+function getNestedMissingProperties(parentType, prefix) {
+	const result = [];
+	for (const propSymbol of parentType.getProperties()) {
+		const nestedPrefix = `${prefix}.${propSymbol.getName()}`;
+		result.push({
+			key: nestedPrefix,
+			value: new UndefinedArgValue()
+		});
+		const propType = propSymbol.getValueDeclaration()?.getType();
+		if (propType) {
+			const objType = extractObjectType(propType);
+			if (objType) result.push(...getNestedMissingProperties(objType, nestedPrefix));
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/extraction/valueTypeDetector.ts
+/**
+* 有効な値種別の一覧
+*/
+const VALID_VALUE_TYPES = [
+	"boolean",
+	"number",
+	"string",
+	"enum",
+	"undefined"
+];
+/**
+* ArgValueから種別を判定する
+*
+* @param value - ArgValue インスタンス
+* @returns 検出された種別、または判定不能な場合は null
+*/
+function detectValueType(value) {
+	if (value instanceof BooleanLiteralArgValue) return "boolean";
+	if (value instanceof UndefinedArgValue) return "undefined";
+	if (value instanceof EnumLiteralArgValue) return "enum";
+	if (value instanceof StringLiteralArgValue) return "string";
+	if (value instanceof NumberLiteralArgValue) return "number";
+	return null;
+}
+/**
+* 値が指定された種別に含まれるか判定する
+*
+* @param value - ArgValue インスタンス
+* @param allowedTypes - 許可する種別の配列、または "all"
+* @returns 指定種別に含まれる場合は true
+*/
+function matchesValueTypes(value, allowedTypes) {
+	if (allowedTypes === "all") return true;
+	const detectedType = detectValueType(value);
+	if (detectedType === null) return false;
+	return allowedTypes.includes(detectedType);
+}
+
+//#endregion
+//#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/analyzer/baseAnalyzer.ts
+/**
+* 宣言ごとの使用状況プロファイル（行番号とパラメータ使用状況）
+*/
+var DeclarationUsageProfile = class {
+	sourceLine;
+	candidatesByParam;
+	/** 総呼び出し回数（ネストしたプロパティの存在チェックに使用） */
+	totalCallCount;
+	constructor(sourceLine, candidatesByParam, totalCallCount) {
+		this.sourceLine = sourceLine;
+		this.candidatesByParam = candidatesByParam;
+		this.totalCallCount = totalCallCount;
+	}
+	/**
+	* 定数として認識されるパラメータを返す
+	*/
+	*findConstantParams(minUsages) {
+		for (const [paramName, candidate] of this.candidatesByParam) if (candidate.isConstant(minUsages, this.totalCallCount)) yield [paramName, candidate];
+	}
+};
+/**
+* ファイル内の宣言（関数/コンポーネント）を管理するレジストリ
+*/
+var DeclarationRegistry = class extends Map {
+	/**
+	* AnalyzedDeclaration から DeclarationUsageProfile を作成して追加
+	*/
+	addFromDeclaration(analyzedDeclaration) {
+		const paramMap = /* @__PURE__ */ new Map();
+		for (const [paramName, usages] of analyzedDeclaration.usages.entries()) paramMap.set(paramName, new ConstantCandidate(usages));
+		const totalCallCount = Math.max(...[...analyzedDeclaration.usages.values()].map((usages) => usages.length), 0);
+		this.set(analyzedDeclaration.name, new DeclarationUsageProfile(analyzedDeclaration.sourceLine, paramMap, totalCallCount));
+	}
+};
+/**
+* 使用状況を階層的に管理するレジストリ
+*
+* 2階層の構造で使用状況を整理する:
+* 1. ソースファイルパス: どのファイルで定義された宣言か
+* 2. 宣言名: 関数名/コンポーネント名（+ 行番号とパラメータ使用状況）
+*
+* この構造により、定数検出時に効率的に走査できる。
+*/
+var UsageRegistry = class UsageRegistry extends Map {
+	/**
+	* DeclarationRegistry を取得（存在しなければ作成）
+	*/
+	getOrCreateDeclarationRegistry(sourceFilePath) {
+		let declarationRegistry = this.get(sourceFilePath);
+		if (!declarationRegistry) {
+			declarationRegistry = new DeclarationRegistry();
+			this.set(sourceFilePath, declarationRegistry);
+		}
+		return declarationRegistry;
+	}
+	/**
+	* AnalyzedDeclarations から UsageRegistry を作成
+	*/
+	static fromDeclarations(declarations) {
+		const usageRegistry = new UsageRegistry();
+		for (const analyzedDeclaration of declarations) usageRegistry.getOrCreateDeclarationRegistry(analyzedDeclaration.sourceFilePath).addFromDeclaration(analyzedDeclaration);
+		return usageRegistry;
+	}
+	/**
+	* すべての定数パラメータをフラットに取得
+	*/
+	*findAllConstantParams(minUsages) {
+		for (const [sourceFile, declarationRegistry] of this) for (const [declarationName, usageProfile] of declarationRegistry) for (const [paramName, candidate] of usageProfile.findConstantParams(minUsages)) yield {
+			sourceFile,
+			declarationName,
+			declarationLine: usageProfile.sourceLine,
+			paramName,
+			candidate
+		};
+	}
+};
+/**
+* 分析処理の基底クラス
+*/
+var BaseAnalyzer = class {
+	shouldExcludeFile;
+	minUsages;
+	allowedValueTypes;
+	callSiteMap;
+	constructor(options = {}) {
+		this.shouldExcludeFile = options.shouldExcludeFile ?? isTestOrStorybookFile;
+		this.minUsages = options.minUsages ?? 2;
+		this.allowedValueTypes = options.allowedValueTypes ?? "all";
+	}
+	/**
+	* 呼び出し情報を設定する
+	* パラメータ経由で渡された値を解決するために使用
+	*
+	* @param callSiteMap - 呼び出し情報マップ
+	*/
+	setCallSiteMap(callSiteMap) {
+		this.callSiteMap = callSiteMap;
+	}
+	/**
+	* 式のリゾルバを取得する
+	*/
+	getExpressionResolver() {
+		return new ExpressionResolver(this.callSiteMap);
+	}
+	/**
+	* 識別子から全参照を検索し、除外対象ファイルからの参照をフィルタリングする
+	*
+	* @param nameNode - 検索対象の識別子ノード
+	* @returns フィルタリングされた参照エントリの配列
+	*/
+	findFilteredReferences(nameNode) {
+		return nameNode.findReferences().flatMap((referencedSymbol) => referencedSymbol.getReferences()).filter((ref) => !this.shouldExcludeFile(ref.getSourceFile().getFilePath()));
+	}
+	/**
+	* ノードからパラメータ定義を取得する
+	*
+	* 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 classifiedDeclarations - 事前分類済みの宣言配列
+	*/
+	analyze(classifiedDeclarations) {
+		const declarations = this.collect(classifiedDeclarations);
+		const usageRegistry = UsageRegistry.fromDeclarations(declarations);
+		return {
+			constantParams: this.extractConstantParams(usageRegistry),
+			declarations
+		};
+	}
+	/**
+	* 常に同じ値が渡されているパラメータを抽出
+	*/
+	extractConstantParams(usageRegistry) {
+		const constantParams = new ConstantParams();
+		for (const entry of usageRegistry.findAllConstantParams(this.minUsages)) {
+			const { sourceFile, declarationName, declarationLine, paramName, candidate } = entry;
+			const value = candidate.representativeValue;
+			if (value instanceof FunctionArgValue || value instanceof ParamRefArgValue || value instanceof MethodCallLiteralArgValue) continue;
+			if (!matchesValueTypes(value, this.allowedValueTypes)) continue;
+			constantParams.push({
+				declarationName,
+				declarationSourceFile: sourceFile,
+				declarationLine,
+				paramName,
+				value,
+				usages: candidate.usages
+			});
+		}
+		return constantParams;
+	}
+};
+
+//#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 classifiedDeclarations - 事前分類済みの宣言配列（type: "class"）
+	* @returns 分析対象のメソッドとその使用状況（名前は「ClassName.methodName」形式）
+	*/
+	collect(classifiedDeclarations) {
+		const analyzedDeclarations = new AnalyzedDeclarations();
+		for (const classifiedDeclaration of classifiedDeclarations) {
+			const { exportName, sourceFile, declaration } = classifiedDeclaration;
+			if (!Node.isClassDeclaration(declaration)) continue;
+			const methods = declaration.getMethods();
+			for (const method of methods) {
+				const methodName = method.getName();
+				const parameters = this.getParameterDefinitions(method);
+				const usageGroup = new UsagesByParam();
+				const analyzed = {
+					name: `${exportName}.${methodName}`,
+					sourceFilePath: sourceFile.getFilePath(),
+					sourceLine: method.getStartLineNumber(),
+					definitions: parameters,
+					declaration: method,
+					usages: usageGroup
+				};
+				const nameNode = method.getNameNode();
+				if (!Node.isIdentifier(nameNode)) continue;
+				const references = this.findFilteredReferences(nameNode);
+				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, analyzed, this.getExpressionResolver());
+					usageGroup.addAll(usages);
+				}
+				analyzedDeclarations.push(analyzed);
+			}
+		}
+		return analyzedDeclarations;
+	}
+};
+
+//#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 classifiedDeclarations - 事前分類済みの宣言配列（type: "function"）
+	* @returns 分析対象の関数とその使用状況
+	*/
+	collect(classifiedDeclarations) {
+		const analyzedDeclarations = new AnalyzedDeclarations();
+		for (const classifiedDeclaration of classifiedDeclarations) {
+			const { exportName, sourceFile, declaration } = classifiedDeclaration;
+			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 usageGroup = new UsagesByParam();
+			const analyzed = {
+				name: exportName,
+				sourceFilePath: sourceFile.getFilePath(),
+				sourceLine: declaration.getStartLineNumber(),
+				definitions: parameters,
+				declaration,
+				usages: usageGroup
+			};
+			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, analyzed, this.getExpressionResolver());
+				usageGroup.addAll(usages);
+			}
+			analyzedDeclarations.push(analyzed);
+		}
+		return analyzedDeclarations;
+	}
+};
+
+//#endregion
+//#region src/react/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 classifiedDeclarations = [];
+	for (const sourceFile of sourceFiles) {
+		const exportedDecls = sourceFile.getExportedDeclarations();
+		for (const [exportName, declarations] of exportedDecls) {
+			const functionLikeDeclaration = declarations.find((declaration) => isFunctionLike(declaration));
+			if (functionLikeDeclaration) {
+				if (Node.isFunctionDeclaration(functionLikeDeclaration) || Node.isVariableDeclaration(functionLikeDeclaration)) {
+					const type = isReactComponent(functionLikeDeclaration) ? "react" : "function";
+					classifiedDeclarations.push({
+						exportName,
+						sourceFile,
+						declaration: functionLikeDeclaration,
+						type
+					});
+				}
+				continue;
+			}
+			const classDeclaration = declarations.find((declaration) => Node.isClassDeclaration(declaration));
+			if (classDeclaration && Node.isClassDeclaration(classDeclaration)) classifiedDeclarations.push({
+				exportName,
+				sourceFile,
+				declaration: classDeclaration,
+				type: "class"
+			});
+		}
+	}
+	return classifiedDeclarations;
+}
+/**
+* 宣言が関数的なもの（関数宣言、アロー関数、関数式）かどうかを判定
+*/
+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, allowedValueTypes = "all", 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,
+		allowedValueTypes
+	};
+	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 {
+		constantParams: ConstantParams.merge(functionResult.constantParams, classMethodResult.constantParams),
+		declarations: AnalyzedDeclarations.merge(functionResult.declarations, classMethodResult.declarations)
+	};
+}
+
+//#endregion
+//#region src/react/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 declaration of declarations) if (Node.isPropertySignature(declaration) && declaration.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 classifiedDeclarations - 事前分類済みの宣言配列
+	* @returns 分析対象のコンポーネントとその使用状況
+	*/
+	collect(classifiedDeclarations) {
+		const analyzedDeclarations = new AnalyzedDeclarations();
+		for (const classifiedDeclaration of classifiedDeclarations) {
+			const { exportName, sourceFile, declaration } = classifiedDeclaration;
+			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 usageGroup = new UsagesByParam();
+			const analyzed = {
+				name: exportName,
+				sourceFilePath: sourceFile.getFilePath(),
+				sourceLine: declaration.getStartLineNumber(),
+				definitions: props,
+				declaration,
+				usages: usageGroup
+			};
+			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, analyzed.definitions, this.getExpressionResolver());
+				usageGroup.addAll(usages);
+			}
+			analyzedDeclarations.push(analyzed);
+		}
+		return analyzedDeclarations;
+	}
+};
+
+//#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, allowedValueTypes = "all", callSiteMap } = options;
+	const components = classifyDeclarations(sourceFiles).filter((decl) => decl.type === "react");
+	const analyzer = new ComponentAnalyzer({
+		shouldExcludeFile,
+		minUsages,
+		allowedValueTypes
+	});
+	analyzer.setCallSiteMap(callSiteMap);
+	return analyzer.analyze(components);
+}
+
+//#endregion
+//#region src/domain/callSiteInfo.ts
+/**
+* 関数/コンポーネントへの呼び出し情報を管理するクラス
+* key: パラメータ名, value: 渡された値の配列
+*/
+var CallSiteInfo = class extends Map {
+	/**
+	* 引数情報を追加する
+	* 既存の配列がある場合は追加、ない場合は新規作成
+	*/
+	addArg(name, arg) {
+		const args = this.get(name) ?? [];
+		args.push(arg);
+		this.set(name, args);
+	}
+};
+
+//#endregion
+//#region src/domain/callSiteMap.ts
+/**
+* すべての関数/コンポーネントの呼び出し情報を管理するクラス
+*/
+var CallSiteMap = class extends Map {
+	/**
+	* 引数情報をCallSiteInfoに追加する
+	*/
+	addArg(targetId, arg) {
+		this.getOrCreateInfo(targetId).addArg(arg.name, arg);
+	}
+	/**
+	* パラメータ参照を解決してArgValueを返す
+	* callSiteMapを使ってパラメータに渡されたすべての値を取得し、
+	* すべて同じ値ならその値を返す。解決できない場合は元のParamRefArgValueを返す。
+	*/
+	resolveParamRef(paramRef) {
+		const resolved = this.resolveParameterValueInternal(paramRef);
+		if (resolved !== void 0) return resolved;
+		return paramRef;
+	}
+	/**
+	* パラメータ参照を解決する（内部メソッド）
+	* callSiteMapを使って、パラメータに渡されたすべての値を取得し、
+	* すべて同じ値ならその値を返す。異なる値があればundefinedを返す。
+	*/
+	resolveParameterValueInternal(paramRef, visited = /* @__PURE__ */ new Set()) {
+		const key = paramRef.toKey();
+		if (visited.has(key)) return;
+		visited.add(key);
+		const { filePath, functionName, path } = paramRef;
+		const targetId = `${filePath}:${functionName}`;
+		const callSiteInfo = this.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) {
+			let resolved;
+			if (arg.value instanceof ParamRefArgValue) resolved = this.resolveParameterValueInternal(arg.value, new Set(visited));
+			else resolved = arg.value;
+			if (resolved === void 0) return;
+			const resolvedKey = resolved.toKey();
+			resolvedKeys.add(resolvedKey);
+			resolvedValue = resolved;
+		}
+		if (resolvedKeys.size === 1) return resolvedValue;
+	}
+	/**
+	* targetIdに対応する呼び出し情報を取得する
+	* 存在しない場合は新規作成して登録する
+	*/
+	getOrCreateInfo(targetId) {
+		let callSiteInfo = this.get(targetId);
+		if (!callSiteInfo) {
+			callSiteInfo = new CallSiteInfo();
+			this.set(targetId, callSiteInfo);
+		}
+		return callSiteInfo;
+	}
+};
+
+//#endregion
+//#region src/extraction/callSiteCollector.ts
+/**
+* ソースファイルから呼び出し情報を収集する
+*/
+var CallSiteCollector = class {
+	shouldExcludeFile;
+	callSiteMap;
+	constructor(shouldExcludeFile = isTestOrStorybookFile) {
+		this.shouldExcludeFile = shouldExcludeFile;
+		this.callSiteMap = new CallSiteMap();
+	}
+	/**
+	* ソースファイルからすべての呼び出し情報を収集する
+	*/
+	collect(sourceFiles) {
+		for (const sourceFile of sourceFiles) {
+			if (this.shouldExcludeFile(sourceFile.getFilePath())) continue;
+			for (const jsxElement of sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement)) this.extractFromJsxElement(jsxElement);
+			for (const jsxElement of sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement)) this.extractFromJsxElement(jsxElement);
+			for (const callExpression of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) this.extractFromCallExpression(callExpression);
+		}
+		return this.callSiteMap;
+	}
+	/**
+	* JSX要素から呼び出し情報を抽出して登録する
+	* タグ名がIdentifierでない場合や、宣言が解決できない場合は何もしない
+	*/
+	extractFromJsxElement(jsxElement) {
+		const tagName = jsxElement.getTagNameNode();
+		if (!Node.isIdentifier(tagName)) return;
+		const declaration = this.getDeclaration(tagName);
+		if (!declaration) return;
+		const targetId = this.createTargetId(declaration, tagName.getText());
+		const filePath = jsxElement.getSourceFile().getFilePath();
+		const line = jsxElement.getStartLineNumber();
+		const attributesWithName = this.getAttributesWithName(jsxElement);
+		for (const { name, node } of attributesWithName) this.callSiteMap.addArg(targetId, {
+			name,
+			value: extractArgValue(node),
+			filePath,
+			line
+		});
+	}
+	/**
+	* 関数呼び出しから呼び出し情報を抽出して登録する
+	* 呼び出し式がIdentifierでない場合や、宣言が解決できない場合は何もしない
+	*/
+	extractFromCallExpression(callExpression) {
+		const calleeExpression = callExpression.getExpression();
+		if (!Node.isIdentifier(calleeExpression)) return;
+		const declaration = this.getDeclaration(calleeExpression);
+		if (!declaration) return;
+		const targetId = this.createTargetId(declaration, calleeExpression.getText());
+		const filePath = callExpression.getSourceFile().getFilePath();
+		const line = callExpression.getStartLineNumber();
+		const argsWithName = this.getArgsWithName(declaration, callExpression.getArguments());
+		for (const { name, node } of argsWithName) this.callSiteMap.addArg(targetId, {
+			name,
+			value: extractArgValue(node),
+			filePath,
+			line
+		});
+	}
+	/**
+	* 宣言からパラメータ名と引数ノードのペア配列を取得する
+	* 関数宣言、アロー関数、関数式に対応
+	* 引数が省略されている場合、node は undefined になる
+	*/
+	getArgsWithName(declaration, args) {
+		let paramNames = [];
+		if (Node.isFunctionDeclaration(declaration)) paramNames = declaration.getParameters().map((p) => p.getName());
+		else if (Node.isVariableDeclaration(declaration)) {
+			const initializer = declaration.getInitializer();
+			if (initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) paramNames = initializer.getParameters().map((p) => p.getName());
+		}
+		return paramNames.map((name, i) => ({
+			name,
+			node: args[i]
+		}));
+	}
+	/**
+	* JSX要素から属性名とノードのペア配列を取得する
+	*/
+	getAttributesWithName(jsxElement) {
+		return jsxElement.getAttributes().filter(Node.isJsxAttribute).map((attr) => ({
+			name: attr.getNameNode().getText(),
+			node: attr
+		}));
+	}
+	/**
+	* 宣言ノードと名前からtargetIdを生成する
+	* 形式: "{ファイルパス}:{名前}"
+	*/
+	createTargetId(declaration, name) {
+		return `${declaration.getSourceFile().getFilePath()}:${name}`;
+	}
+	/**
+	* 識別子から定義元の宣言ノードを取得する
+	* インポートを通じて実際の定義を解決し、宣言ノードを返す
+	*/
+	getDeclaration(identifier) {
+		const symbol = identifier.getSymbol();
+		return (symbol?.getAliasedSymbol() ?? symbol)?.getDeclarations()[0];
+	}
+};
+
+//#endregion
+export { isTestOrStorybookFile as a, AnalyzedDeclarations as c, analyzeFunctionsCore as i, CallSiteMap as n, VALID_VALUE_TYPES as o, analyzePropsCore as r, ConstantParams as s, CallSiteCollector as t };
+//# sourceMappingURL=callSiteCollector-CGFPm0in.mjs.map