@generaltranslation/compiler 1.3.21 → 1.3.23

package/dist/transform/validation/validateTranslationFunction.js

@@ -1,355 +1,244 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateTranslationFunction = validateTranslationFunction;
-exports.validateUseTranslationsCallback = validateUseTranslationsCallback;
-exports.validateUseMessagesCallback = validateUseMessagesCallback;
-exports.validateDerive = validateDerive;
-const t = __importStar(require("@babel/types"));
-const constants_1 = require("../../utils/constants/gt/constants");
-const getCalleeNameFromExpression_1 = require("../../utils/parsing/getCalleeNameFromExpression");
-const resolveStaticExpression_1 = require("../../utils/string-expressions/resolveStaticExpression");
-const getTrackedVariable_1 = require("../getTrackedVariable");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+require("../../utils/constants/gt/constants.js");
+const require_utils_parsing_getCalleeNameFromExpression = require("../../utils/parsing/getCalleeNameFromExpression.js");
+const require_utils_string_expressions_resolveStaticExpression = require("../../utils/string-expressions/resolveStaticExpression.js");
+const require_transform_getTrackedVariable = require("../getTrackedVariable.js");
+let _babel_types = require("@babel/types");
+_babel_types = require_runtime.__toESM(_babel_types);
+//#region src/transform/validation/validateTranslationFunction.ts
 /**
- * Validate useGT_callback / getGT_callback / msg() / t()
- * - first argument must be a statically resolvable string expression
- *   (string literal, template literal, binary '+' concatenation, or derive() call)
- * - second argument, if present, $id field + $context field must be a string literal
- */
+* Validate useGT_callback / getGT_callback / msg() / t()
+* - first argument must be a statically resolvable string expression
+*   (string literal, template literal, binary '+' concatenation, or derive() call)
+* - second argument, if present, $id field + $context field must be a string literal
+*/
 function validateTranslationFunction(callExprPath, state) {
-    var _a;
-    const callExpr = callExprPath.node;
-    const errors = [];
-    // Validate that the function has at least 1 argument
-    if (callExpr.arguments.length < 1) {
-        errors.push('registration function must have at least 1 argument');
-        return { errors };
-    }
-    // Validate first argument
-    if (!t.isExpression(callExpr.arguments[0])) {
-        errors.push('registration function must use a string literal or derive() call as the first argument. Variable content is not allowed.');
-        return { errors };
-    }
-    // Try to resolve the expression to a static string (handles concat, nested templates, etc.)
-    const resolvedStaticExpression = (0, resolveStaticExpression_1.resolveStaticExpression)(callExprPath.get('arguments')[0]);
-    // TODO: until we implement derivation, we will only need to check the first value
-    const content = (_a = resolvedStaticExpression.values) === null || _a === void 0 ? void 0 : _a[0];
-    const resolutionErrors = getResolutionErrorMessages(resolvedStaticExpression.errors, false);
-    if (resolutionErrors.length > 0) {
-        return { errors: resolutionErrors };
-    }
-    if (content === undefined && !state.settings.autoderive.strings) {
-        // Not a static expression — check if it contains a derive() function invocation
-        validateDerive(callExpr.arguments[0], state, errors);
-        if (errors.length > 0) {
-            errors.push(...getResolutionErrorMessages(resolvedStaticExpression.errors));
-            errors.push('registration function must use a string literal or derive() call as the first argument. Variable content is not allowed.');
-            return { errors };
-        }
-    }
-    // TODO: hasDeriveContext should be refactored to enforce no hash generated HERE in this function
-    // instead of passing that information outside of this function.
-    // We skip hash gen with autoderive, derive in content, and derive in $context. This flag is being
-    // reused for all 3 cases.
-    const contentHasAutoderive = state.settings.autoderive.strings && content === undefined;
-    // Validate second argument
-    let context;
-    let id;
-    let hash;
-    let maxChars;
-    let format;
-    let hasDeriveContext;
-    if (callExpr.arguments.length === 1) {
-        return {
-            errors,
-            content,
-            hasDeriveContext: contentHasAutoderive || undefined,
-        };
-    }
-    if (t.isObjectExpression(callExpr.arguments[1])) {
-        const objExprPath = callExprPath.get('arguments')[1];
-        const contextProperty = validatePropertyFromObjectExpression(objExprPath, constants_1.USEGT_CALLBACK_OPTIONS.$context, 'string-or-derive', state);
-        errors.push(...contextProperty.errors);
-        context = contextProperty.value;
-        hasDeriveContext =
-            contentHasAutoderive || contextProperty.hasDeriveExpression;
-        const idProperty = validatePropertyFromObjectExpression(objExprPath, constants_1.USEGT_CALLBACK_OPTIONS.$id, 'string');
-        errors.push(...idProperty.errors);
-        id = idProperty.value;
-        const maxCharsProperty = validatePropertyFromObjectExpression(objExprPath, constants_1.USEGT_CALLBACK_OPTIONS.$maxChars, 'number');
-        errors.push(...maxCharsProperty.errors);
-        maxChars = maxCharsProperty.value;
-        const hashProperty = validatePropertyFromObjectExpression(objExprPath, constants_1.USEGT_CALLBACK_OPTIONS.$_hash, 'string');
-        errors.push(...hashProperty.errors);
-        hash = hashProperty.value;
-        const formatProperty = validatePropertyFromObjectExpression(objExprPath, constants_1.USEGT_CALLBACK_OPTIONS.$format, 'string');
-        errors.push(...formatProperty.errors);
-        format = formatProperty.value;
-    }
-    return {
-        errors,
-        content,
-        context,
-        id,
-        hash,
-        maxChars,
-        format,
-        hasDeriveContext,
-    };
+	var _resolvedStaticExpres;
+	const callExpr = callExprPath.node;
+	const errors = [];
+	if (callExpr.arguments.length < 1) {
+		errors.push("registration function must have at least 1 argument");
+		return { errors };
+	}
+	if (!_babel_types.isExpression(callExpr.arguments[0])) {
+		errors.push("registration function must use a string literal or derive() call as the first argument. Variable content is not allowed.");
+		return { errors };
+	}
+	const resolvedStaticExpression = require_utils_string_expressions_resolveStaticExpression.resolveStaticExpression(callExprPath.get("arguments")[0]);
+	const content = (_resolvedStaticExpres = resolvedStaticExpression.values) === null || _resolvedStaticExpres === void 0 ? void 0 : _resolvedStaticExpres[0];
+	const resolutionErrors = getResolutionErrorMessages(resolvedStaticExpression.errors, false);
+	if (resolutionErrors.length > 0) return { errors: resolutionErrors };
+	if (content === void 0 && !state.settings.autoderive.strings) {
+		validateDerive(callExpr.arguments[0], state, errors);
+		if (errors.length > 0) {
+			errors.push(...getResolutionErrorMessages(resolvedStaticExpression.errors));
+			errors.push("registration function must use a string literal or derive() call as the first argument. Variable content is not allowed.");
+			return { errors };
+		}
+	}
+	const contentHasAutoderive = state.settings.autoderive.strings && content === void 0;
+	let context;
+	let id;
+	let hash;
+	let maxChars;
+	let format;
+	let hasDeriveContext;
+	if (callExpr.arguments.length === 1) return {
+		errors,
+		content,
+		hasDeriveContext: contentHasAutoderive || void 0
+	};
+	if (_babel_types.isObjectExpression(callExpr.arguments[1])) {
+		const objExprPath = callExprPath.get("arguments")[1];
+		const contextProperty = validatePropertyFromObjectExpression(objExprPath, "$context", "string-or-derive", state);
+		errors.push(...contextProperty.errors);
+		context = contextProperty.value;
+		hasDeriveContext = contentHasAutoderive || contextProperty.hasDeriveExpression;
+		const idProperty = validatePropertyFromObjectExpression(objExprPath, "$id", "string");
+		errors.push(...idProperty.errors);
+		id = idProperty.value;
+		const maxCharsProperty = validatePropertyFromObjectExpression(objExprPath, "$maxChars", "number");
+		errors.push(...maxCharsProperty.errors);
+		maxChars = maxCharsProperty.value;
+		const hashProperty = validatePropertyFromObjectExpression(objExprPath, "$_hash", "string");
+		errors.push(...hashProperty.errors);
+		hash = hashProperty.value;
+		const formatProperty = validatePropertyFromObjectExpression(objExprPath, "$format", "string");
+		errors.push(...formatProperty.errors);
+		format = formatProperty.value;
+	}
+	return {
+		errors,
+		content,
+		context,
+		id,
+		hash,
+		maxChars,
+		format,
+		hasDeriveContext
+	};
 }
 /**
- * Validate useTranslations_callback / getTranslations_callback
- * - always valid (arguments can be dynamic)
- */
-// eslint-disable-next-line no-unused-vars
+* Validate useTranslations_callback / getTranslations_callback
+* - always valid (arguments can be dynamic)
+*/
 function validateUseTranslationsCallback(_callExpr) {
-    const errors = [];
-    return { errors };
+	return { errors: [] };
 }
 /**
- * Validate useMessages_callback / getMessages_callback
- * - always valid
- */
-// eslint-disable-next-line no-unused-vars
+* Validate useMessages_callback / getMessages_callback
+* - always valid
+*/
 function validateUseMessagesCallback(_callExpr) {
-    const errors = [];
-    return { errors };
+	return { errors: [] };
 }
-/* =============================== */
-/* Helper Functions */
-/* =============================== */
 function getResolutionErrorMessages(errors, includeDynamic = true) {
-    return errors
-        .filter((error) => includeDynamic || error.kind !== 'dynamic-expression')
-        .map(({ message }) => message);
+	return errors.filter((error) => includeDynamic || error.kind !== "dynamic-expression").map(({ message }) => message);
 }
 function validatePropertyFromObjectExpression(objExprPath, name, type, state) {
-    var _a;
-    const result = { errors: [] };
-    let valuePath;
-    for (const propertyPath of objExprPath.get('properties')) {
-        if (!propertyPath.isObjectProperty()) {
-            continue;
-        }
-        const property = propertyPath.node;
-        if (t.isIdentifier(property.key) && property.key.name === name) {
-            valuePath = propertyPath;
-            break;
-        }
-        if (t.isStringLiteral(property.key) && property.key.value === name) {
-            valuePath = propertyPath;
-            break;
-        }
-    }
-    // return result if no value found
-    if (!valuePath) {
-        return result;
-    }
-    const value = valuePath.node;
-    // validate value
-    if (!t.isExpression(value.value)) {
-        result.errors.push(`registration function must use a string literal for its ${name} field. Variable content is not allowed.`);
-        return result;
-    }
-    // extract value
-    if (type === 'string-or-derive') {
-        const resolved = (0, resolveStaticExpression_1.resolveStaticExpression)(valuePath.get('value'));
-        const resolutionErrors = getResolutionErrorMessages(resolved.errors, false);
-        // TODO: until we implement derivation, we will only need to check the first value
-        if (((_a = resolved.values) === null || _a === void 0 ? void 0 : _a[0]) !== undefined) {
-            result.value = resolved.values[0];
-        }
-        else if (resolutionErrors.length > 0) {
-            result.errors.push(...resolutionErrors);
-        }
-        else if (state) {
-            // Static resolution failed — check if it's a valid derive() expression
-            const deriveErrors = [];
-            validateDerive(value.value, state, deriveErrors);
-            if (deriveErrors.length === 0) {
-                result.hasDeriveExpression = true;
-            }
-            else {
-                result.errors.push(...getResolutionErrorMessages(resolved.errors), ...deriveErrors);
-            }
-        }
-        else {
-            result.errors.push(...getResolutionErrorMessages(resolved.errors));
-        }
-    }
-    else {
-        const validatedValue = type === 'string'
-            ? validateExpressionIsStringLiteral(value.value)
-            : validateExpressionIsNumericLiteral(value.value);
-        result.errors.push(...validatedValue.errors);
-        result.value = validatedValue.value;
-    }
-    return result;
+	const result = { errors: [] };
+	let valuePath;
+	for (const propertyPath of objExprPath.get("properties")) {
+		if (!propertyPath.isObjectProperty()) continue;
+		const property = propertyPath.node;
+		if (_babel_types.isIdentifier(property.key) && property.key.name === name) {
+			valuePath = propertyPath;
+			break;
+		}
+		if (_babel_types.isStringLiteral(property.key) && property.key.value === name) {
+			valuePath = propertyPath;
+			break;
+		}
+	}
+	if (!valuePath) return result;
+	const value = valuePath.node;
+	if (!_babel_types.isExpression(value.value)) {
+		result.errors.push(`registration function must use a string literal for its ${name} field. Variable content is not allowed.`);
+		return result;
+	}
+	if (type === "string-or-derive") {
+		var _resolved$values;
+		const resolved = require_utils_string_expressions_resolveStaticExpression.resolveStaticExpression(valuePath.get("value"));
+		const resolutionErrors = getResolutionErrorMessages(resolved.errors, false);
+		if (((_resolved$values = resolved.values) === null || _resolved$values === void 0 ? void 0 : _resolved$values[0]) !== void 0) result.value = resolved.values[0];
+		else if (resolutionErrors.length > 0) result.errors.push(...resolutionErrors);
+		else if (state) {
+			const deriveErrors = [];
+			validateDerive(value.value, state, deriveErrors);
+			if (deriveErrors.length === 0) result.hasDeriveExpression = true;
+			else result.errors.push(...getResolutionErrorMessages(resolved.errors), ...deriveErrors);
+		} else result.errors.push(...getResolutionErrorMessages(resolved.errors));
+	} else {
+		const validatedValue = type === "string" ? validateExpressionIsStringLiteral(value.value) : validateExpressionIsNumericLiteral(value.value);
+		result.errors.push(...validatedValue.errors);
+		result.value = validatedValue.value;
+	}
+	return result;
 }
 /**
- * Validate that an expression is a string literal
- */
+* Validate that an expression is a string literal
+*/
 function validateExpressionIsStringLiteral(expr) {
-    var _a;
-    if (t.isStringLiteral(expr)) {
-        return { errors: [], value: expr.value };
-    }
-    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
-        return { errors: [], value: (_a = expr.quasis[0]) === null || _a === void 0 ? void 0 : _a.value.cooked };
-    }
-    return { errors: ['Expression is not a string literal'] };
+	if (_babel_types.isStringLiteral(expr)) return {
+		errors: [],
+		value: expr.value
+	};
+	if (_babel_types.isTemplateLiteral(expr) && expr.expressions.length === 0) {
+		var _expr$quasis$;
+		return {
+			errors: [],
+			value: (_expr$quasis$ = expr.quasis[0]) === null || _expr$quasis$ === void 0 ? void 0 : _expr$quasis$.value.cooked
+		};
+	}
+	return { errors: ["Expression is not a string literal"] };
 }
 /**
- * Validates if an expression uses the derive() function correctly
- */
+* Validates if an expression uses the derive() function correctly
+*/
 function validateDerive(expr, state, errors) {
-    if (!expr) {
-        errors.push('Expression is empty');
-        return { errors };
-    }
-    // 1. Direct call: derive(node)
-    if (t.isCallExpression(expr)) {
-        // Find the canonical function name
-        const { namespaceName, functionName } = (0, getCalleeNameFromExpression_1.getCalleeNameFromExpression)(expr);
-        // Get the canonical function name
-        const { canonicalName, type } = (0, getTrackedVariable_1.getTrackedVariable)(state.scopeTracker, namespaceName, functionName);
-        if (!canonicalName) {
-            errors.push('Expression does not use an allowed call expression');
-            return { errors };
-        }
-        // Validate the function is actually the GT derive function
-        if (type !== 'generaltranslation' ||
-            (canonicalName !== constants_1.GT_OTHER_FUNCTIONS.declareStatic &&
-                canonicalName !== constants_1.GT_OTHER_FUNCTIONS.derive)) {
-            errors.push('Expression does not use an allowed call expression');
-            return { errors };
-        }
-        // Validate that the call expression has exactly one argument and the argument is a call expression
-        validateDeclareStaticExpression(expr, errors);
-        return { errors };
-    }
-    // 2. String concatenation: "Hello there " + derive(getName())
-    if (t.isBinaryExpression(expr) && expr.operator === '+') {
-        if (!t.isExpression(expr.left) || !t.isExpression(expr.right)) {
-            errors.push('Operands must be expressions');
-            return { errors };
-        }
-        validateDerive(expr.right, state, errors);
-        validateDerive(expr.left, state, errors);
-        return { errors };
-    }
-    // 3. Template literal: `Hello there ${derive(getName())}` or `static text`
-    if (t.isTemplateLiteral(expr)) {
-        if (expr.expressions.length === 0) {
-            return { errors };
-        }
-        if (!expr.expressions.some((expression) => t.isExpression(expression) &&
-            validateDerive(expression, state, errors).errors.length === 0)) {
-            errors.push('Expression does not use an allowed call expression');
-        }
-        return {
-            errors,
-        };
-    }
-    // 4. Static literals (string, number, boolean, null)
-    if (t.isStringLiteral(expr)) {
-        return { errors };
-    }
-    if (t.isNumericLiteral(expr)) {
-        return { errors };
-    }
-    if (t.isBooleanLiteral(expr)) {
-        return { errors };
-    }
-    if (t.isNullLiteral(expr)) {
-        return { errors };
-    }
-    // Fallthrough: expression type not supported (e.g., plain identifiers/variables)
-    errors.push('Variables are not allowed');
-    return { errors };
+	if (!expr) {
+		errors.push("Expression is empty");
+		return { errors };
+	}
+	if (_babel_types.isCallExpression(expr)) {
+		const { namespaceName, functionName } = require_utils_parsing_getCalleeNameFromExpression.getCalleeNameFromExpression(expr);
+		const { canonicalName, type } = require_transform_getTrackedVariable.getTrackedVariable(state.scopeTracker, namespaceName, functionName);
+		if (!canonicalName) {
+			errors.push("Expression does not use an allowed call expression");
+			return { errors };
+		}
+		if (type !== "generaltranslation" || canonicalName !== "declareStatic" && canonicalName !== "derive") {
+			errors.push("Expression does not use an allowed call expression");
+			return { errors };
+		}
+		validateDeclareStaticExpression(expr, errors);
+		return { errors };
+	}
+	if (_babel_types.isBinaryExpression(expr) && expr.operator === "+") {
+		if (!_babel_types.isExpression(expr.left) || !_babel_types.isExpression(expr.right)) {
+			errors.push("Operands must be expressions");
+			return { errors };
+		}
+		validateDerive(expr.right, state, errors);
+		validateDerive(expr.left, state, errors);
+		return { errors };
+	}
+	if (_babel_types.isTemplateLiteral(expr)) {
+		if (expr.expressions.length === 0) return { errors };
+		if (!expr.expressions.some((expression) => _babel_types.isExpression(expression) && validateDerive(expression, state, errors).errors.length === 0)) errors.push("Expression does not use an allowed call expression");
+		return { errors };
+	}
+	if (_babel_types.isStringLiteral(expr)) return { errors };
+	if (_babel_types.isNumericLiteral(expr)) return { errors };
+	if (_babel_types.isBooleanLiteral(expr)) return { errors };
+	if (_babel_types.isNullLiteral(expr)) return { errors };
+	errors.push("Variables are not allowed");
+	return { errors };
 }
 /**
- * Takes in a call expression to check if:
- * - it has exactly one argument
- * - the argument is a call expression
- * Example: derive(getName())
- */
+* Takes in a call expression to check if:
+* - it has exactly one argument
+* - the argument is a call expression
+* Example: derive(getName())
+*/
 function validateDeclareStaticExpression(expr, errors) {
-    // Validate that the function has 1 argument
-    if (expr.arguments.length !== 1) {
-        errors.push('derive() must have one argument');
-        return { errors };
-    }
-    const [onlyArg] = expr.arguments;
-    // Await expression: derive(await ...)
-    if (t.isAwaitExpression(onlyArg)) {
-        // Validate that the awaited expression is a call expression
-        if (!t.isCallExpression(onlyArg.argument)) {
-            errors.push('derive() must have a call expression as the argument');
-            return { errors };
-        }
-        // Valid: derive(await someFunction())
-        return { errors };
-    }
-    // Validate that the argument is a call expression
-    if (!t.isCallExpression(onlyArg)) {
-        errors.push('derive() must have a call expression as the argument');
-        return { errors };
-    }
-    return { errors };
+	if (expr.arguments.length !== 1) {
+		errors.push("derive() must have one argument");
+		return { errors };
+	}
+	const [onlyArg] = expr.arguments;
+	if (_babel_types.isAwaitExpression(onlyArg)) {
+		if (!_babel_types.isCallExpression(onlyArg.argument)) {
+			errors.push("derive() must have a call expression as the argument");
+			return { errors };
+		}
+		return { errors };
+	}
+	if (!_babel_types.isCallExpression(onlyArg)) {
+		errors.push("derive() must have a call expression as the argument");
+		return { errors };
+	}
+	return { errors };
 }
 /**
- * Validate that an expression is a number literal
- */
+* Validate that an expression is a number literal
+*/
 function validateExpressionIsNumericLiteral(expr) {
-    let candidateValue;
-    if (t.isNumericLiteral(expr)) {
-        candidateValue = expr.value;
-    }
-    else if (t.isUnaryExpression(expr) && t.isNumericLiteral(expr.argument)) {
-        // Note: taking the absolute value of the number literal
-        candidateValue = expr.argument.value;
-    }
-    // validate is integer
-    if (candidateValue !== undefined && !Number.isInteger(candidateValue)) {
-        return { errors: ['Expression is not an integer'] };
-    }
-    // no value found
-    if (candidateValue === undefined) {
-        return { errors: ['Expression is not a number literal'] };
-    }
-    return { errors: [], value: candidateValue };
+	let candidateValue;
+	if (_babel_types.isNumericLiteral(expr)) candidateValue = expr.value;
+	else if (_babel_types.isUnaryExpression(expr) && _babel_types.isNumericLiteral(expr.argument)) candidateValue = expr.argument.value;
+	if (candidateValue !== void 0 && !Number.isInteger(candidateValue)) return { errors: ["Expression is not an integer"] };
+	if (candidateValue === void 0) return { errors: ["Expression is not a number literal"] };
+	return {
+		errors: [],
+		value: candidateValue
+	};
 }
+//#endregion
+exports.validateDerive = validateDerive;
+exports.validateTranslationFunction = validateTranslationFunction;
+exports.validateUseMessagesCallback = validateUseMessagesCallback;
+exports.validateUseTranslationsCallback = validateUseTranslationsCallback;
+
 //# sourceMappingURL=validateTranslationFunction.js.map