@intlayer/babel 9.3.0 → 9.3.2

package/dist/cjs/babel-plugin-intlayer-usage-analyzer.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
 //#region src/babel-plugin-intlayer-usage-analyzer.ts
 const createPruneContext = () => ({
 	dictionaryKeyToFieldUsageMap: /* @__PURE__ */ new Map(),
@@ -55,6 +54,21 @@ const preserveNestedDictionaryFields = (pruneContext, nestedDictionaryReferences
 		for (const nestedField of nestedFields) currentFieldUsage.add(nestedField);
 	}
 };
+/**
+* Methods the runtime attaches to a resolved content object rather than fields
+* declared in a `.content` file.
+*
+* `vanilla-intlayer`'s `useIntlayer` / `useDictionary` assign `onChange` onto
+* the content they return, so `useIntlayer('app').onChange(cb)` is a
+* subscription — not a read of a field named `onChange`. Without this list the
+* analyser records `onChange` as the only consumed field and the purge pass
+* strips every real field from the compiled dictionary.
+*
+* The analyser looks *through* these calls: the callback parameter is analysed
+* as a fresh content root, and the call result is analysed again because the
+* helpers return the content object for chaining.
+*/
+const CHAINABLE_RUNTIME_METHOD_NAMES = /* @__PURE__ */ new Set(["onChange"]);
 /** Canonical intlayer caller names that trigger usage analysis. */
 const INTLAYER_CALLER_NAMES = ["useIntlayer", "getIntlayer"];
 /**
@@ -99,7 +113,6 @@ const recordFieldUsage = (pruneContext, dictionaryKey, fieldUsage) => {
 *   const result = useIntlayer('key')               → records 'all' (untracked binding)
 */
 const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath, dictionaryKey, currentSourceFilePath, isSfcFile) => {
-	const parentNode = callExpressionPath.parent;
 	/** Mark the dictionary key as having an untracked binding in this file. */
 	const markUntrackedBinding = () => {
 		const existingPaths = pruneContext.dictionaryKeysWithUntrackedBindings.get(dictionaryKey) ?? [];
@@ -227,32 +240,64 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 		}
 		return true;
 	};
-	if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id)) {
-		const accessedFieldNames = /* @__PURE__ */ new Set();
-		if (collectFieldsFromObjectPattern(parentNode.id, callExpressionPath, accessedFieldNames)) recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
-		else recordFieldUsage(pruneContext, dictionaryKey, "all");
-		return;
-	}
-	if ((babelTypes.isMemberExpression(parentNode) || babelTypes.isOptionalMemberExpression(parentNode)) && parentNode.object === callExpressionPath.node) {
-		let fieldName;
-		if (!parentNode.computed && babelTypes.isIdentifier(parentNode.property)) fieldName = parentNode.property.name;
-		else if (parentNode.computed && babelTypes.isStringLiteral(parentNode.property)) fieldName = parentNode.property.value;
-		if (fieldName) {
-			recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([fieldName]));
-			const memberExprPath = callExpressionPath.parentPath;
-			if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
-		} else markUntrackedBinding();
-		return;
-	}
-	if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isIdentifier(parentNode.id)) {
-		const variableName = parentNode.id.name;
-		const variableBinding = callExpressionPath.scope.getBinding(variableName);
-		if (!variableBinding) {
+	/**
+	* Returns the call path when `memberExprPath` is a chainable runtime helper
+	* being invoked (`content.onChange(cb)`), otherwise `undefined`.
+	*
+	* See {@link CHAINABLE_RUNTIME_METHOD_NAMES}: a bare `content.onChange`
+	* reference that is never called is treated as an ordinary field access, so
+	* only the invoked form is looked through.
+	*/
+	const getChainedRuntimeCallPath = (memberExprPath, fieldName) => {
+		if (!CHAINABLE_RUNTIME_METHOD_NAMES.has(fieldName)) return void 0;
+		if (!memberExprPath) return void 0;
+		const callPath = memberExprPath.parentPath;
+		if (!callPath) return void 0;
+		if (!callPath.isCallExpression() && !callPath.isOptionalCallExpression()) return;
+		if (callPath.node.callee !== memberExprPath.node) return;
+		return callPath;
+	};
+	/**
+	* Analyses the callbacks handed to a chainable runtime helper.
+	*
+	* The callback receives the freshly-resolved content root, so its parameter
+	* is walked exactly like `const content = useIntlayer('key')` — either as a
+	* plain binding or as a destructuring pattern.
+	*/
+	const analyzeChainedCallbackArguments = (callPath) => {
+		const argumentPaths = callPath.get("arguments");
+		for (const argumentPath of argumentPaths) {
+			if (!argumentPath.isArrowFunctionExpression() && !argumentPath.isFunctionExpression()) continue;
+			const [firstParameterPath] = argumentPath.get("params");
+			if (!firstParameterPath) continue;
+			if (firstParameterPath.isIdentifier()) {
+				const parameterBinding = argumentPath.scope.getBinding(firstParameterPath.node.name);
+				if (!parameterBinding) {
+					markUntrackedBinding();
+					continue;
+				}
+				const accessedFieldNames = /* @__PURE__ */ new Set();
+				if (analyzeContentBindingReferences(parameterBinding, accessedFieldNames)) markUntrackedBinding();
+				else recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
+				continue;
+			}
+			if (firstParameterPath.isObjectPattern()) {
+				const accessedFieldNames = /* @__PURE__ */ new Set();
+				if (collectFieldsFromObjectPattern(firstParameterPath.node, argumentPath, accessedFieldNames)) recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
+				else recordFieldUsage(pruneContext, dictionaryKey, "all");
+				continue;
+			}
 			markUntrackedBinding();
-			return;
 		}
-		const accessedTopLevelFieldNames = /* @__PURE__ */ new Set();
-		let hasUntrackedReferenceAccess = false;
+	};
+	/**
+	* Walks every reference of a local binding holding the content root,
+	* collecting the top-level fields it reads into `accessedTopLevelFieldNames`.
+	*
+	* @returns `true` when a reference escaped static tracking, meaning the whole
+	*   dictionary must be kept.
+	*/
+	const analyzeContentBindingReferences = (variableBinding, accessedTopLevelFieldNames) => {
 		for (const variableReferencePath of variableBinding.referencePaths) {
 			const referenceParentNode = variableReferencePath.parent;
 			if ((babelTypes.isMemberExpression(referenceParentNode) || babelTypes.isOptionalMemberExpression(referenceParentNode)) && referenceParentNode.object === variableReferencePath.node) {
@@ -261,17 +306,18 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 				if (!memberExpressionNode.computed && babelTypes.isIdentifier(memberExpressionNode.property)) fieldName = memberExpressionNode.property.name;
 				else if (memberExpressionNode.computed && babelTypes.isStringLiteral(memberExpressionNode.property)) fieldName = memberExpressionNode.property.value;
 				if (fieldName) {
-					accessedTopLevelFieldNames.add(fieldName);
 					const memberExprPath = variableReferencePath.parentPath;
+					const chainedCallPath = getChainedRuntimeCallPath(memberExprPath, fieldName);
+					if (chainedCallPath) {
+						analyzeChainedCallbackArguments(chainedCallPath);
+						analyzeContentRoot(chainedCallPath);
+						continue;
+					}
+					accessedTopLevelFieldNames.add(fieldName);
 					if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
-				} else {
-					hasUntrackedReferenceAccess = true;
-					break;
-				}
-			} else if (babelTypes.isArrayExpression(referenceParentNode)) {
-				hasUntrackedReferenceAccess = true;
-				break;
-			} else if ((babelTypes.isCallExpression(referenceParentNode) || babelTypes.isOptionalCallExpression(referenceParentNode)) && referenceParentNode.callee === variableReferencePath.node) {
+				} else return true;
+			} else if (babelTypes.isArrayExpression(referenceParentNode)) return true;
+			else if ((babelTypes.isCallExpression(referenceParentNode) || babelTypes.isOptionalCallExpression(referenceParentNode)) && referenceParentNode.callee === variableReferencePath.node) {
 				const callExprPath = variableReferencePath.parentPath;
 				const callParent = callExprPath?.parent;
 				if (callParent && (babelTypes.isMemberExpression(callParent) || babelTypes.isOptionalMemberExpression(callParent)) && callParent.object === callExprPath?.node) {
@@ -280,30 +326,71 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 					if (!memberExpr.computed && babelTypes.isIdentifier(memberExpr.property)) fieldName = memberExpr.property.name;
 					else if (memberExpr.computed && babelTypes.isStringLiteral(memberExpr.property)) fieldName = memberExpr.property.value;
 					if (fieldName) {
-						accessedTopLevelFieldNames.add(fieldName);
 						const memberExprPath = callExprPath?.parentPath;
+						const chainedCallPath = getChainedRuntimeCallPath(memberExprPath, fieldName);
+						if (chainedCallPath) {
+							analyzeChainedCallbackArguments(chainedCallPath);
+							analyzeContentRoot(chainedCallPath);
+							continue;
+						}
+						accessedTopLevelFieldNames.add(fieldName);
 						if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
-					} else {
-						hasUntrackedReferenceAccess = true;
-						break;
-					}
-				} else if (callParent && babelTypes.isVariableDeclarator(callParent) && babelTypes.isObjectPattern(callParent.id) && callExprPath && collectFieldsFromObjectPattern(callParent.id, callExprPath, accessedTopLevelFieldNames)) {} else {
-					hasUntrackedReferenceAccess = true;
-					break;
+					} else return true;
+				} else if (callParent && babelTypes.isVariableDeclarator(callParent) && babelTypes.isObjectPattern(callParent.id) && callExprPath && collectFieldsFromObjectPattern(callParent.id, callExprPath, accessedTopLevelFieldNames)) {} else return true;
+			} else return true;
+		}
+		return false;
+	};
+	/**
+	* Analyses how the content root referenced by `rootPath` is consumed.
+	*
+	* `rootPath` is the `useIntlayer('key')` call itself, or any expression that
+	* evaluates back to the same content object — currently the result of a
+	* chainable runtime helper such as `.onChange(…)`.
+	*/
+	const analyzeContentRoot = (rootPath) => {
+		const parentNode = rootPath.parent;
+		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id)) {
+			const accessedFieldNames = /* @__PURE__ */ new Set();
+			if (collectFieldsFromObjectPattern(parentNode.id, rootPath, accessedFieldNames)) recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
+			else recordFieldUsage(pruneContext, dictionaryKey, "all");
+			return;
+		}
+		if ((babelTypes.isMemberExpression(parentNode) || babelTypes.isOptionalMemberExpression(parentNode)) && parentNode.object === rootPath.node) {
+			let fieldName;
+			if (!parentNode.computed && babelTypes.isIdentifier(parentNode.property)) fieldName = parentNode.property.name;
+			else if (parentNode.computed && babelTypes.isStringLiteral(parentNode.property)) fieldName = parentNode.property.value;
+			if (fieldName) {
+				const memberExprPath = rootPath.parentPath;
+				const chainedCallPath = getChainedRuntimeCallPath(memberExprPath, fieldName);
+				if (chainedCallPath) {
+					analyzeChainedCallbackArguments(chainedCallPath);
+					analyzeContentRoot(chainedCallPath);
+					return;
 				}
-			} else {
-				hasUntrackedReferenceAccess = true;
-				break;
+				recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([fieldName]));
+				if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
+			} else markUntrackedBinding();
+			return;
+		}
+		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isIdentifier(parentNode.id)) {
+			const variableName = parentNode.id.name;
+			const variableBinding = rootPath.scope.getBinding(variableName);
+			if (!variableBinding) {
+				markUntrackedBinding();
+				return;
 			}
+			const accessedTopLevelFieldNames = /* @__PURE__ */ new Set();
+			if (analyzeContentBindingReferences(variableBinding, accessedTopLevelFieldNames)) markUntrackedBinding();
+			else if (isSfcFile) deferFrameworkAnalysis(variableName);
+			else if (variableBinding.referencePaths.length === 0) markUntrackedBinding();
+			else recordFieldUsage(pruneContext, dictionaryKey, accessedTopLevelFieldNames);
+			return;
 		}
-		if (hasUntrackedReferenceAccess) markUntrackedBinding();
-		else if (isSfcFile) deferFrameworkAnalysis(variableName);
-		else if (variableBinding.referencePaths.length === 0) markUntrackedBinding();
-		else recordFieldUsage(pruneContext, dictionaryKey, accessedTopLevelFieldNames);
-		return;
-	}
-	if (babelTypes.isExpressionStatement(parentNode)) return;
-	markUntrackedBinding();
+		if (babelTypes.isExpressionStatement(parentNode)) return;
+		markUntrackedBinding();
+	};
+	analyzeContentRoot(callExpressionPath);
 };
 /**
 * Reads a fully-static string from an AST node. Returns `undefined` for
@@ -647,6 +734,7 @@ const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelT
 };
 
 //#endregion
+exports.CHAINABLE_RUNTIME_METHOD_NAMES = CHAINABLE_RUNTIME_METHOD_NAMES;
 exports.DEFAULT_COMPAT_CALLERS = DEFAULT_COMPAT_CALLERS;
 exports.INTLAYER_CALLER_NAMES = INTLAYER_CALLER_NAMES;
 exports.createPruneContext = createPruneContext;