@gtkx/cli 1.4.0 → 1.6.0

package/dist/i18n/binding-extractor.js

@@ -0,0 +1,1324 @@
+import { types as babel, parseAsync, traverse } from "@babel/core";
+import { extname } from "node:path";
+const API_NAMES = [
+    "IcuTrans",
+    "IcuTransWithoutContext",
+    "Trans",
+    "TransWithoutContext",
+    "Translation",
+    "getFixedT",
+    "getI18n",
+    "init",
+    "t",
+    "useTranslation",
+    "withTranslation",
+];
+const API_NAME_SET = new Set(API_NAMES);
+const GTKX_MODULE = "@gtkx/i18n";
+const I18NEXT_MODULE = "i18next";
+const REACT_I18NEXT_MODULE = "react-i18next";
+const SUPPORTED_MODULES = new Set([GTKX_MODULE, I18NEXT_MODULE, REACT_I18NEXT_MODULE]);
+const I18NEXT_APIS = new Set(["getFixedT", "init", "t"]);
+const CONTEXT_SEPARATOR = "\u{4}";
+const EMPTY_INFO = {};
+const GLOBAL_T = { fixed: false, info: EMPTY_INFO, kind: "t" };
+const oneChild = (path, key) => {
+    const value = path.get(key);
+    return Array.isArray(value) || value.node === null ? undefined : value;
+};
+const childPaths = (path, key) => {
+    const value = path.get(key);
+    return Array.isArray(value)
+        ? value.filter((candidate) => candidate.node !== null)
+        : [];
+};
+const isTransparentExpression = (path) => [
+    path.isParenthesizedExpression(),
+    path.isTSAsExpression(),
+    path.isTSInstantiationExpression(),
+    path.isTSNonNullExpression(),
+    path.isTSSatisfiesExpression(),
+    path.isTSTypeAssertion(),
+].includes(true);
+const unwrapPath = (path) => {
+    let current = path;
+    while (isTransparentExpression(current)) {
+        const expression = oneChild(current, "expression");
+        if (expression === undefined) {
+            return current;
+        }
+        current = expression;
+    }
+    return current;
+};
+const staticPropertyName = (path) => {
+    if (path.isIdentifier()) {
+        return path.node.name;
+    }
+    if (path.isStringLiteral()) {
+        return path.node.value;
+    }
+    return path.isNumericLiteral() ? String(path.node.value) : undefined;
+};
+const memberProperty = (path) => {
+    const member = unwrapPath(path);
+    if (!member.isMemberExpression() && !member.isOptionalMemberExpression()) {
+        return;
+    }
+    const property = oneChild(member, "property");
+    if (property === undefined) {
+        return;
+    }
+    return !member.node.computed && property.isIdentifier()
+        ? property.node.name
+        : staticPropertyName(property);
+};
+const constantDeclaratorBinding = (path, resolving) => {
+    if (!path.isIdentifier()) {
+        return;
+    }
+    const binding = path.scope.getBinding(path.node.name);
+    if (!binding?.constant) {
+        return;
+    }
+    return resolving.has(binding) || !binding.path.isVariableDeclarator()
+        ? undefined
+        : binding;
+};
+const literalIdentifierString = (path, resolving) => {
+    const binding = constantDeclaratorBinding(path, resolving);
+    if (binding === undefined) {
+        return;
+    }
+    const init = oneChild(binding.path, "init");
+    if (init === undefined) {
+        return;
+    }
+    resolving.add(binding);
+    const resolved = literalString(init, resolving);
+    resolving.delete(binding);
+    return resolved;
+};
+const literalMemberString = (path, resolving) => {
+    const object = oneChild(path, "object");
+    const property = memberProperty(path);
+    if (property === undefined || object?.isIdentifier() !== true) {
+        return;
+    }
+    const binding = constantDeclaratorBinding(object, resolving);
+    if (binding === undefined) {
+        return;
+    }
+    const member = objectProperty(oneChild(binding.path, "init"), property);
+    if (member === undefined) {
+        return;
+    }
+    resolving.add(binding);
+    const resolved = literalString(member, resolving);
+    resolving.delete(binding);
+    return resolved;
+};
+const directLiteralString = (value) => {
+    if (value.isStringLiteral()) {
+        return value.node.value;
+    }
+    if (!value.isTemplateLiteral() || value.node.expressions.length > 0) {
+        return;
+    }
+    const quasi = value.node.quasis[0];
+    return quasi?.value.cooked ?? quasi?.value.raw;
+};
+const literalString = (path, resolving = new Set()) => {
+    if (path === undefined) {
+        return;
+    }
+    const value = unwrapPath(path);
+    const direct = directLiteralString(value);
+    if (direct !== undefined) {
+        return direct;
+    }
+    return value.isIdentifier()
+        ? literalIdentifierString(value, resolving)
+        : literalMemberString(value, resolving);
+};
+const isStaticObjectProperty = (path, resolving) => {
+    if (!path.isSpreadElement()) {
+        return true;
+    }
+    return isStaticObject(oneChild(path, "argument"), resolving);
+};
+const isStaticObject = (path, resolving = new Set()) => {
+    if (path === undefined) {
+        return false;
+    }
+    const value = unwrapPath(path);
+    const binding = constantDeclaratorBinding(value, resolving);
+    if (binding !== undefined) {
+        resolving.add(binding);
+        const isResult = isStaticObject(oneChild(binding.path, "init"), resolving);
+        resolving.delete(binding);
+        return isResult;
+    }
+    return value.isObjectExpression() &&
+        childPaths(value, "properties").every((property) => isStaticObjectProperty(property, resolving));
+};
+const propertyKeyName = (property) => {
+    const key = oneChild(property, "key");
+    if (key === undefined) {
+        return;
+    }
+    const propertyName = property.node.computed
+        ? literalString(key)
+        : staticPropertyName(key);
+    if (propertyName === undefined && property.node.computed) {
+        throw new Error("Translation options cannot contain dynamic computed properties");
+    }
+    return propertyName;
+};
+const spreadPropertyValue = (property, name, resolving) => {
+    const argument = oneChild(property, "argument");
+    const spread = objectProperty(argument, name, resolving);
+    if (spread !== undefined) {
+        return spread;
+    }
+    if (!isStaticObject(argument)) {
+        throw new Error("Translation options cannot contain dynamic object spreads");
+    }
+    return undefined;
+};
+const directPropertyValue = (property, name) => {
+    if (!property.isObjectMethod() && !property.isObjectProperty()) {
+        return;
+    }
+    if (propertyKeyName(property) !== name) {
+        return;
+    }
+    if (property.isObjectMethod()) {
+        return property;
+    }
+    const key = oneChild(property, "key");
+    return property.node.shorthand ? key : oneChild(property, "value");
+};
+const objectPropertyEntry = (property, name, resolving) => property.isSpreadElement()
+    ? spreadPropertyValue(property, name, resolving)
+    : directPropertyValue(property, name);
+const objectExpressionProperty = (value, name, resolving) => {
+    for (const property of childPaths(value, "properties").toReversed()) {
+        const result = objectPropertyEntry(property, name, resolving);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    return undefined;
+};
+const objectProperty = (path, name, resolving = new Set()) => {
+    if (path === undefined) {
+        return;
+    }
+    const value = unwrapPath(path);
+    const binding = constantDeclaratorBinding(value, resolving);
+    if (binding !== undefined) {
+        resolving.add(binding);
+        const resolved = objectProperty(oneChild(binding.path, "init"), name, resolving);
+        resolving.delete(binding);
+        return resolved;
+    }
+    if (!value.isObjectExpression()) {
+        return;
+    }
+    return objectExpressionProperty(value, name, resolving);
+};
+const resolvedNamespaceIdentifier = (value, resolving) => {
+    const binding = constantDeclaratorBinding(value, resolving);
+    if (binding === undefined) {
+        return;
+    }
+    resolving.add(binding);
+    const resolved = namespaceValues(oneChild(binding.path, "init"), resolving);
+    resolving.delete(binding);
+    return resolved;
+};
+const namespaceValues = (path, resolving = new Set()) => {
+    const direct = literalString(path);
+    if (direct !== undefined) {
+        return [direct];
+    }
+    if (path === undefined) {
+        return [];
+    }
+    const value = unwrapPath(path);
+    const resolved = resolvedNamespaceIdentifier(value, resolving);
+    if (resolved !== undefined) {
+        return resolved;
+    }
+    if (!value.isArrayExpression()) {
+        return [];
+    }
+    const values = childPaths(value, "elements").map((element) => literalString(element, resolving));
+    return values.every((candidate) => candidate !== undefined) ? values : [];
+};
+const normalizedInfo = (namespaces, keyPrefix) => {
+    const info = {};
+    const defaultNs = namespaces[0];
+    if (defaultNs !== undefined) {
+        info.defaultNs = defaultNs;
+        if (namespaces.length > 1) {
+            info.namespaces = namespaces;
+        }
+    }
+    if (keyPrefix !== undefined && keyPrefix.length > 0) {
+        info.keyPrefix = keyPrefix;
+    }
+    return info;
+};
+const isAbsentArgument = (path) => {
+    if (path.isNullLiteral()) {
+        return true;
+    }
+    return path.isIdentifier() &&
+        path.node.name === "undefined" &&
+        path.scope.getBinding("undefined") === undefined;
+};
+const staticNamespaces = (path, file) => {
+    if (path === undefined || isAbsentArgument(path)) {
+        return [];
+    }
+    const namespaces = namespaceValues(path);
+    if (namespaces.length === 0) {
+        throw new Error(`Translation namespaces must be static strings in ${file}`);
+    }
+    return namespaces;
+};
+const staticKeyPrefix = (path, file) => {
+    if (path === undefined || isAbsentArgument(path)) {
+        return;
+    }
+    const keyPrefix = literalString(path);
+    if (keyPrefix === undefined) {
+        throw new Error(`Translation key prefixes must be static strings in ${file}`);
+    }
+    return keyPrefix;
+};
+const callArguments = (path) => childPaths(path, "arguments");
+const scopeFromCall = (input) => {
+    const args = callArguments(input.path);
+    const options = input.optionsIndex === undefined ? undefined : args[input.optionsIndex];
+    const optionPrefix = staticKeyPrefix(objectProperty(options, "keyPrefix"), input.file);
+    const positional = input.prefixIndex === undefined ? undefined : args[input.prefixIndex];
+    const positionalPrefix = staticKeyPrefix(positional, input.file);
+    return normalizedInfo(staticNamespaces(args[input.namespaceIndex], input.file), optionPrefix ?? positionalPrefix);
+};
+const isApiName = (name) => API_NAME_SET.has(name);
+const isApiAvailable = (moduleName, api) => {
+    if (moduleName === GTKX_MODULE) {
+        return true;
+    }
+    if (moduleName === I18NEXT_MODULE) {
+        return I18NEXT_APIS.has(api);
+    }
+    return moduleName === REACT_I18NEXT_MODULE && !I18NEXT_APIS.has(api);
+};
+const apiSemantic = (api) => api === "t" ? GLOBAL_T : { api, kind: "api" };
+const spanKey = (node) => typeof node.start === "number" && typeof node.end === "number"
+    ? `${String(node.start)}:${String(node.end)}`
+    : undefined;
+const pathLocation = (path, file) => {
+    const start = path.node.loc?.start;
+    return start === undefined
+        ? { file }
+        : { column: start.column, file, line: start.line };
+};
+const patternLocalName = (path) => {
+    const value = unwrapPath(path);
+    if (value.isIdentifier()) {
+        return value.node.name;
+    }
+    const left = value.isAssignmentPattern() ? oneChild(value, "left") : undefined;
+    return left?.isIdentifier() === true ? left.node.name : undefined;
+};
+const scopeWithPrefix = (info, keyPrefix) => {
+    const scoped = { ...info };
+    if (keyPrefix.length === 0) {
+        delete scoped.keyPrefix;
+    }
+    else {
+        scoped.keyPrefix = keyPrefix;
+    }
+    return scoped;
+};
+const isClassPath = (path) => path.isClass();
+const isCallPath = (path) => path.isCallExpression() || path.isOptionalCallExpression();
+const isMemberPath = (path) => path.isMemberExpression() || path.isOptionalMemberExpression();
+const isStaticStringArray = (path) => path !== undefined && literalString(path) === undefined && namespaceValues(path).length > 0;
+const analyzeProgram = (program, file) => new BindingAnalyzer(file).analyze(program);
+const parserPlugins = (path) => {
+    const extension = extname(path).toLowerCase();
+    const plugins = ["decorators-legacy"];
+    if ([".cts", ".mts", ".ts", ".tsx"].includes(extension)) {
+        plugins.push("typescript");
+    }
+    if ([".cjs", ".js", ".jsx", ".mjs", ".tsx"].includes(extension)) {
+        plugins.push("jsx");
+    }
+    return plugins;
+};
+const extractBindings = async (code, path) => {
+    const ast = await parseAsync(code, {
+        babelrc: false,
+        configFile: false,
+        filename: path,
+        parserOpts: {
+            plugins: parserPlugins(path),
+            sourceType: "unambiguous",
+        },
+    });
+    if (ast === null) {
+        throw new Error(`Unable to parse ${path}`);
+    }
+    let extraction;
+    traverse(ast, {
+        Program(programPath) {
+            extraction = analyzeProgram(programPath, path);
+            programPath.stop();
+        },
+    });
+    if (extraction === undefined) {
+        throw new Error(`Unable to analyze ${path}`);
+    }
+    return extraction;
+};
+class BindingAnalyzer {
+    bindingCache = new Map();
+    blockedGetFixedT = new Set();
+    calls = new Map();
+    errors = new Set();
+    file;
+    hocClasses = new Map();
+    messages = [];
+    resolving = new Set();
+    specialBindings = new Map();
+    trans = new Map();
+    constructor(file) {
+        this.file = file;
+    }
+    runSemanticPass(program) {
+        program.traverse({
+            CallExpression: this.registerCallSemantics.bind(this),
+            JSXElement: this.registerJsxElement.bind(this),
+            OptionalCallExpression: this.registerCallSemantics.bind(this),
+            VariableDeclarator: this.registerBlockedGetFixedT.bind(this),
+        });
+    }
+    runTranslationPass(program) {
+        program.traverse({
+            CallExpression: this.registerTranslationCall.bind(this),
+            OptionalCallExpression: this.registerTranslationCall.bind(this),
+            TaggedTemplateExpression: this.registerTaggedTranslation.bind(this),
+        });
+    }
+    importSemantic(binding) {
+        const path = binding.path;
+        const declaration = path.parentPath;
+        if (!declaration.isImportDeclaration()) {
+            return;
+        }
+        if (this.isTypeImport(path, declaration)) {
+            return;
+        }
+        const moduleName = declaration.node.source.value;
+        if (path.isImportNamespaceSpecifier()) {
+            return SUPPORTED_MODULES.has(moduleName) ? { kind: "namespace", module: moduleName } : undefined;
+        }
+        return this.importSpecifierSemantic(path, moduleName);
+    }
+    isTypeImport(path, declaration) {
+        return declaration.node.importKind === "type" ||
+            (path.isImportSpecifier() && path.node.importKind === "type");
+    }
+    importSpecifierSemantic(path, moduleName) {
+        if (path.isImportDefaultSpecifier()) {
+            return moduleName === I18NEXT_MODULE
+                ? { kind: "namespace", module: moduleName }
+                : undefined;
+        }
+        return path.isImportSpecifier()
+            ? this.namedImportSemantic(path, moduleName)
+            : undefined;
+    }
+    namedImportSemantic(path, moduleName) {
+        const imported = path.node.imported;
+        const name = babel.isIdentifier(imported) ? imported.name : imported.value;
+        return isApiName(name) && isApiAvailable(moduleName, name)
+            ? apiSemantic(name)
+            : undefined;
+    }
+    semanticMember(object, property) {
+        if (object.kind === "namespace") {
+            return this.namespaceMember(object.module, property);
+        }
+        return this.localSemanticMember(object, property);
+    }
+    namespaceMember(moduleName, property) {
+        return isApiName(property) && isApiAvailable(moduleName, property)
+            ? apiSemantic(property)
+            : undefined;
+    }
+    localSemanticMember(object, property) {
+        if (object.kind === "translationContext") {
+            return property === "i18n"
+                ? { instance: true, kind: "translationObject", t: GLOBAL_T }
+                : undefined;
+        }
+        return object.kind === "translationObject"
+            ? this.translationObjectMember(object, property)
+            : undefined;
+    }
+    translationObjectMember(object, property) {
+        if (["0", "t"].includes(property)) {
+            return object.t;
+        }
+        if (!object.instance && ["1", "i18n"].includes(property)) {
+            return { instance: true, kind: "translationObject", t: GLOBAL_T };
+        }
+        return object.instance && ["getFixedT", "init"].includes(property)
+            ? { api: property, kind: "api" }
+            : undefined;
+    }
+    resolvePath(input) {
+        const path = unwrapPath(input);
+        if (path.isIdentifier()) {
+            return this.resolveIdentifierPath(path);
+        }
+        if (isMemberPath(path)) {
+            return this.resolveMemberPath(path);
+        }
+        if (isCallPath(path)) {
+            return this.resolveCallPath(path);
+        }
+        return path.isAwaitExpression()
+            ? this.resolveAwaitPath(path)
+            : undefined;
+    }
+    resolveIdentifierPath(path) {
+        const binding = path.scope.getBinding(path.node.name);
+        return binding === undefined ? undefined : this.resolveBinding(binding);
+    }
+    resolveMemberPath(path) {
+        const objectPath = oneChild(path, "object");
+        const property = memberProperty(path);
+        if (objectPath === undefined || property === undefined) {
+            return;
+        }
+        const object = this.resolvePath(objectPath);
+        return object === undefined ? undefined : this.semanticMember(object, property);
+    }
+    resolveCallPath(path) {
+        const callee = oneChild(path, "callee");
+        if (callee === undefined) {
+            return;
+        }
+        const required = this.requireSemantic(path, callee);
+        if (required !== undefined) {
+            return required;
+        }
+        const called = this.resolvePath(callee);
+        return called?.kind === "api" ? this.apiCallSemantic(called.api, path) : undefined;
+    }
+    requireSemantic(path, callee) {
+        if (!callee.isIdentifier() || callee.node.name !== "require") {
+            return;
+        }
+        if (callee.scope.getBinding(callee.node.name) !== undefined) {
+            return;
+        }
+        const moduleName = literalString(callArguments(path)[0]);
+        return moduleName !== undefined && SUPPORTED_MODULES.has(moduleName)
+            ? { kind: "namespace", module: moduleName }
+            : undefined;
+    }
+    apiCallSemantic(api, path) {
+        switch (api) {
+            case "useTranslation": {
+                return this.useTranslationSemantic(path);
+            }
+            case "getI18n": {
+                return { instance: true, kind: "translationObject", t: GLOBAL_T };
+            }
+            case "getFixedT": {
+                return this.fixedTranslationSemantic(path);
+            }
+            case "withTranslation": {
+                return this.translationEnhancerSemantic(path);
+            }
+            case "init": {
+                return { kind: "initPromise" };
+            }
+            case "IcuTrans":
+            case "IcuTransWithoutContext":
+            case "Trans":
+            case "TransWithoutContext":
+            case "Translation":
+            case "t": {
+                return;
+            }
+        }
+    }
+    useTranslationSemantic(path) {
+        const info = scopeFromCall({ file: this.file, namespaceIndex: 0, optionsIndex: 1, path });
+        return {
+            instance: false,
+            kind: "translationObject",
+            t: { fixed: true, info, kind: "t" },
+        };
+    }
+    fixedTranslationSemantic(path) {
+        const info = scopeFromCall({
+            file: this.file,
+            namespaceIndex: 1,
+            path,
+            prefixIndex: 2,
+        });
+        return { fixed: true, info, kind: "t" };
+    }
+    translationEnhancerSemantic(path) {
+        const info = scopeFromCall({ file: this.file, namespaceIndex: 0, optionsIndex: 1, path });
+        return { info, kind: "enhancer" };
+    }
+    resolveAwaitPath(path) {
+        const argument = oneChild(path, "argument");
+        const awaited = argument === undefined ? undefined : this.resolvePath(argument);
+        return awaited?.kind === "initPromise" ? GLOBAL_T : undefined;
+    }
+    resolveBinding(binding) {
+        const special = this.specialBindings.get(binding);
+        if (special !== undefined) {
+            return special;
+        }
+        return binding.constant ? this.resolveConstantBinding(binding) : undefined;
+    }
+    resolveConstantBinding(binding) {
+        const cached = this.bindingCache.get(binding);
+        if (cached !== undefined) {
+            return cached ?? undefined;
+        }
+        if (this.resolving.has(binding)) {
+            return;
+        }
+        this.resolving.add(binding);
+        const resolved = this.importSemantic(binding) ?? this.declaratorSemantic(binding);
+        this.resolving.delete(binding);
+        this.bindingCache.set(binding, resolved ?? null);
+        return resolved;
+    }
+    declaratorSemantic(binding) {
+        const path = binding.path;
+        if (!path.isVariableDeclarator()) {
+            return;
+        }
+        const id = oneChild(path, "id");
+        const init = oneChild(path, "init");
+        if (id === undefined || init === undefined) {
+            return;
+        }
+        if (id.isIdentifier() && id.node.name === binding.identifier.name) {
+            return this.resolvePath(init);
+        }
+        return this.patternDeclaratorSemantic(id, init, binding.identifier.name);
+    }
+    patternDeclaratorSemantic(id, init, name) {
+        if (id.isObjectPattern()) {
+            return this.objectPatternSemantic(id, init, name);
+        }
+        return id.isArrayPattern()
+            ? this.arrayPatternSemantic(id, init, name)
+            : undefined;
+    }
+    objectPatternSemantic(id, init, name) {
+        const object = this.resolvePath(init);
+        if (object === undefined) {
+            return;
+        }
+        for (const property of childPaths(id, "properties")) {
+            const resolved = this.patternPropertySemantic(property, object, name);
+            if (resolved !== undefined) {
+                return resolved;
+            }
+        }
+        return undefined;
+    }
+    patternPropertySemantic(property, object, name) {
+        if (!property.isObjectProperty()) {
+            return;
+        }
+        const key = oneChild(property, "key");
+        const value = oneChild(property, "value");
+        if (key === undefined || value === undefined || patternLocalName(value) !== name) {
+            return;
+        }
+        const propertyName = staticPropertyName(key);
+        return propertyName === undefined ? undefined : this.semanticMember(object, propertyName);
+    }
+    arrayPatternSemantic(id, init, name) {
+        const object = this.resolvePath(init);
+        if (object?.kind !== "translationObject") {
+            return;
+        }
+        const elements = childPaths(id, "elements");
+        if (elements[0] !== undefined && patternLocalName(elements[0]) === name) {
+            return object.t;
+        }
+        return !object.instance && elements[1] !== undefined && patternLocalName(elements[1]) === name
+            ? { instance: true, kind: "translationObject", t: GLOBAL_T }
+            : undefined;
+    }
+    jsxSemantic(path) {
+        if (path.isJSXIdentifier()) {
+            const binding = path.scope.getBinding(path.node.name);
+            return binding === undefined ? undefined : this.resolveBinding(binding);
+        }
+        return path.isJSXMemberExpression()
+            ? this.jsxMemberSemantic(path)
+            : undefined;
+    }
+    jsxMemberSemantic(path) {
+        const object = oneChild(path, "object");
+        const property = oneChild(path, "property");
+        if (object === undefined || property?.isJSXIdentifier() !== true) {
+            return;
+        }
+        const base = this.jsxSemantic(object);
+        return base === undefined
+            ? undefined
+            : this.semanticMember(base, property.node.name);
+    }
+    resolveFunction(input) {
+        if (input === undefined) {
+            return;
+        }
+        const path = unwrapPath(input);
+        if (path.isFunction() || path.isClass()) {
+            return path;
+        }
+        if (!path.isIdentifier()) {
+            return;
+        }
+        return this.resolveFunctionBinding(path.scope.getBinding(path.node.name));
+    }
+    resolveFunctionBinding(binding) {
+        if (binding?.path.isFunctionDeclaration() === true || binding?.path.isClassDeclaration() === true) {
+            return binding.path;
+        }
+        return binding?.path.isVariableDeclarator() === true
+            ? this.resolveFunction(oneChild(binding.path, "init"))
+            : undefined;
+    }
+    registerPatternBinding(path, semantic) {
+        const name = patternLocalName(path);
+        const binding = name === undefined ? undefined : path.scope.getBinding(name);
+        if (binding === undefined) {
+            return;
+        }
+        const existing = this.specialBindings.get(binding);
+        if (existing !== undefined && JSON.stringify(existing) !== JSON.stringify(semantic)) {
+            this.errors.add(`A translation binding cannot be reused with conflicting scopes in ${this.file}`);
+            return;
+        }
+        this.specialBindings.set(binding, semantic);
+    }
+    registerSemanticPattern(path, semantic) {
+        const target = this.semanticPatternTarget(path);
+        if (target.isIdentifier()) {
+            this.registerPatternBinding(target, semantic);
+            return;
+        }
+        if (target.isObjectPattern()) {
+            this.registerObjectSemanticPattern(target, semantic);
+        }
+    }
+    semanticPatternTarget(path) {
+        const target = unwrapPath(path);
+        return target.isAssignmentPattern()
+            ? oneChild(target, "left") ?? target
+            : target;
+    }
+    registerObjectSemanticPattern(pattern, semantic) {
+        for (const property of childPaths(pattern, "properties")) {
+            this.registerSemanticProperty(property, semantic);
+        }
+    }
+    registerSemanticProperty(property, semantic) {
+        if (!property.isObjectProperty()) {
+            return;
+        }
+        const key = oneChild(property, "key");
+        const value = oneChild(property, "value");
+        const name = key === undefined ? undefined : staticPropertyName(key);
+        const member = name === undefined ? undefined : this.semanticMember(semantic, name);
+        if (value !== undefined && member !== undefined) {
+            this.registerSemanticPattern(value, member);
+        }
+    }
+    registerTParameter(fn, index, t) {
+        const parameter = childPaths(fn, "params")[index];
+        if (parameter !== undefined) {
+            this.registerPatternBinding(parameter, t);
+        }
+    }
+    registerHocComponent(component, info) {
+        const target = this.resolveFunction(component);
+        if (target === undefined) {
+            return;
+        }
+        const t = { fixed: true, info, kind: "t" };
+        if (target.isClass()) {
+            this.hocClasses.set(target.node, t);
+            return;
+        }
+        this.registerHocParameter(childPaths(target, "params")[0], t);
+    }
+    registerHocParameter(parameter, t) {
+        if (parameter === undefined) {
+            return;
+        }
+        const unwrapped = unwrapPath(parameter);
+        if (unwrapped.isIdentifier() || unwrapped.isAssignmentPattern()) {
+            this.registerPatternBinding(unwrapped, { instance: false, kind: "translationObject", t });
+            return;
+        }
+        if (unwrapped.isObjectPattern()) {
+            this.registerHocObjectPattern(unwrapped, t);
+        }
+    }
+    registerHocObjectPattern(pattern, t) {
+        for (const property of childPaths(pattern, "properties")) {
+            this.registerHocProperty(property, t);
+        }
+    }
+    registerHocProperty(property, t) {
+        if (!property.isObjectProperty()) {
+            return;
+        }
+        const key = oneChild(property, "key");
+        const value = oneChild(property, "value");
+        if (key !== undefined && value !== undefined && staticPropertyName(key) === "t") {
+            this.registerPatternBinding(value, t);
+        }
+    }
+    jsxAttribute(element, name) {
+        const opening = oneChild(element, "openingElement");
+        if (opening === undefined) {
+            return;
+        }
+        for (const attribute of childPaths(opening, "attributes").toReversed()) {
+            const value = this.jsxAttributeValue(attribute, name);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    jsxAttributeValue(attribute, name) {
+        if (attribute.isJSXSpreadAttribute()) {
+            return objectProperty(oneChild(attribute, "argument"), name);
+        }
+        if (!attribute.isJSXAttribute()) {
+            return;
+        }
+        const attributeName = oneChild(attribute, "name");
+        if (attributeName?.isJSXIdentifier() !== true || attributeName.node.name !== name) {
+            return;
+        }
+        const value = oneChild(attribute, "value");
+        return value?.isJSXExpressionContainer() === true ? oneChild(value, "expression") : value;
+    }
+    scopeFromJsx(element) {
+        return normalizedInfo(staticNamespaces(this.jsxAttribute(element, "ns"), this.file), staticKeyPrefix(this.jsxAttribute(element, "keyPrefix"), this.file));
+    }
+    addComponentMessage(input) {
+        const componentKeys = this.componentKeys(input);
+        if (componentKeys === undefined) {
+            return;
+        }
+        if (!this.validateIcu(input, componentKeys)) {
+            return;
+        }
+        const t = this.componentT(input.tPath);
+        if (!t.isValid) {
+            return;
+        }
+        const context = this.componentContext(input);
+        if (!context.isValid) {
+            return;
+        }
+        const scope = this.componentScope(input, componentKeys.rawKeys, t.value, context.value);
+        this.addScopedComponentMessages(input, componentKeys, scope);
+    }
+    addScopedComponentMessages(input, componentKeys, scope) {
+        if (this.componentHasCount(input)) {
+            this.addPluralComponentMessages(input, componentKeys.fallback, scope);
+        }
+        else {
+            this.addPointComponentMessages(input, componentKeys, scope);
+        }
+    }
+    componentKeys(input) {
+        const optionDefault = objectProperty(input.optionsPath, "defaultValue");
+        const fallback = literalString(input.defaultPath) ?? literalString(optionDefault);
+        const explicitKeys = this.explicitComponentKeys(input.keyPath);
+        if (explicitKeys === undefined) {
+            return;
+        }
+        const rawKeys = explicitKeys.length > 0 ? explicitKeys : this.fallbackKeys(fallback);
+        if (rawKeys.length === 0) {
+            this.errors.add(`Translation components require a static key or default in ${this.file}`);
+            return;
+        }
+        return { fallback, rawKeys };
+    }
+    explicitComponentKeys(keyPath) {
+        if (keyPath === undefined) {
+            return [];
+        }
+        const keys = namespaceValues(keyPath);
+        if (keys.length === 0) {
+            this.errors.add(`Translation component keys must be static strings in ${this.file}`);
+            return;
+        }
+        return keys;
+    }
+    fallbackKeys(fallback) {
+        return fallback === undefined ? [] : [fallback];
+    }
+    validateIcu(input, keys) {
+        if (!input.isIcu) {
+            return true;
+        }
+        if (keys.rawKeys.length > 1) {
+            this.errors.add(`ICU translations require one static key in ${this.file}`);
+            return false;
+        }
+        return this.validateIcuFallback(input, keys.fallback);
+    }
+    validateIcuFallback(input, fallback) {
+        if (fallback === undefined) {
+            this.errors.add(`ICU translations require a static defaultTranslation in ${this.file}`);
+            return false;
+        }
+        const withoutInterpolation = fallback.replaceAll(/\{\{[^{}]+\}\}/gu, "");
+        if (/\{[^{}]+\}/u.test(withoutInterpolation)) {
+            this.errors.add(`GTKX gettext catalogs do not support ICU MessageFormat syntax in ${this.file}`);
+            return false;
+        }
+        return this.validateIcuCount(input, fallback);
+    }
+    validateIcuCount(input, fallback) {
+        const hasValueCount = objectProperty(input.valuesPath, "count") !== undefined;
+        if (hasValueCount || /\{\{\s*count\s*\}\}/u.test(fallback)) {
+            this.errors.add(`ICU translations cannot infer a GNU gettext plural pair in ${this.file}`);
+            return false;
+        }
+        return true;
+    }
+    componentT(path) {
+        if (path === undefined) {
+            return { isValid: true };
+        }
+        const semantic = this.resolvePath(path);
+        if (semantic?.kind !== "t") {
+            this.errors.add(`Translation component t props must have a statically known scope in ${this.file}`);
+            return { isValid: false };
+        }
+        return { isValid: true, value: semantic };
+    }
+    componentContext(input) {
+        const optionContext = objectProperty(input.optionsPath, "context");
+        const contextPath = input.contextPath ?? optionContext;
+        if (contextPath === undefined) {
+            return { isValid: true };
+        }
+        const context = literalString(contextPath);
+        if (context === undefined) {
+            this.errors.add(`Translation contexts must be static strings in ${this.file}`);
+            return { isValid: false };
+        }
+        return { isValid: true, value: context };
+    }
+    componentScope(input, rawKeys, t, context) {
+        const prefix = t?.info.keyPrefix;
+        const baseKeys = rawKeys.map((key) => prefix === undefined ? key : `${prefix}.${key}`);
+        const keys = baseKeys.map((key) => context === undefined
+            ? key
+            : `${key}${CONTEXT_SEPARATOR}${context}`);
+        const explicitNs = staticNamespaces(input.namespacePath, this.file)[0];
+        return { keys, ns: explicitNs ?? t?.info.defaultNs };
+    }
+    componentHasCount(input) {
+        return input.countPath !== undefined ||
+            objectProperty(input.optionsPath, "count") !== undefined ||
+            objectProperty(input.valuesPath, "count") !== undefined;
+    }
+    addPluralComponentMessages(input, fallback, scope) {
+        if (input.isIcu) {
+            this.errors.add(`ICU translations cannot infer a GNU gettext plural pair in ${this.file}`);
+            return;
+        }
+        if (this.hasUnsupportedPluralOptions(input.optionsPath)) {
+            this.errors.add(`GNU gettext catalogs only support cardinal one/other source pairs in ${this.file}`);
+            return;
+        }
+        const defaults = this.pluralDefaults(input.optionsPath, fallback);
+        if (defaults === undefined) {
+            return;
+        }
+        for (const key of scope.keys) {
+            this.addPluralPair({ key, ns: scope.ns, path: input.path, ...defaults });
+        }
+    }
+    pluralDefaults(options, fallback) {
+        const singular = literalString(objectProperty(options, "defaultValue_one")) ?? fallback;
+        const plural = literalString(objectProperty(options, "defaultValue_other"));
+        if (singular === undefined || plural === undefined || singular === plural) {
+            this.errors.add(`Count-based Trans calls require distinct static singular and plural defaults in ${this.file}`);
+            return;
+        }
+        return { plural, singular };
+    }
+    hasUnsupportedPluralOptions(options) {
+        return objectProperty(options, "ordinal") !== undefined ||
+            objectProperty(options, "defaultValue_zero") !== undefined;
+    }
+    addPluralPair(input) {
+        this.addMessage({
+            defaultValue: input.singular,
+            hasExplicitDefault: true,
+            key: `${input.key}_one`,
+            ns: input.ns,
+            path: input.path,
+        });
+        this.addMessage({
+            defaultValue: input.plural,
+            hasExplicitDefault: true,
+            key: `${input.key}_other`,
+            ns: input.ns,
+            path: input.path,
+        });
+    }
+    addPointComponentMessages(input, componentKeys, scope) {
+        for (const [index, key] of scope.keys.entries()) {
+            const defaultValue = componentKeys.fallback ?? componentKeys.rawKeys[index] ?? key;
+            this.addMessage({
+                defaultValue,
+                hasExplicitDefault: componentKeys.fallback !== undefined,
+                key,
+                ns: scope.ns,
+                path: input.path,
+            });
+        }
+    }
+    addMessage(input) {
+        this.messages.push({
+            defaultValue: input.defaultValue,
+            explicitDefault: input.hasExplicitDefault,
+            key: input.key,
+            location: pathLocation(input.path, this.file),
+            ...(input.ns !== undefined && { ns: input.ns }),
+        });
+    }
+    markTranslationCallback(callback, info) {
+        const fn = this.resolveFunction(callback);
+        if (fn !== undefined && !fn.isClass()) {
+            this.registerTParameter(fn, 0, { fixed: true, info, kind: "t" });
+            this.registerTranslationContextParameter(fn);
+        }
+    }
+    registerTranslationContextParameter(fn) {
+        const parameter = childPaths(fn, "params")[1];
+        if (parameter !== undefined) {
+            this.registerSemanticPattern(parameter, { kind: "translationContext" });
+        }
+    }
+    registerCallSemantics(path) {
+        const callee = oneChild(path, "callee");
+        const called = callee === undefined ? undefined : this.resolvePath(callee);
+        this.registerHocCall(path, called);
+        this.registerTranslationCallbackCall(path, called);
+        this.registerInitCallback(path, called);
+        this.registerInitPromiseCallback(path, callee);
+        this.registerCallableComponent(path, called);
+    }
+    registerHocCall(path, called) {
+        if (called?.kind === "enhancer") {
+            this.registerHocComponent(callArguments(path)[0], called.info);
+        }
+    }
+    registerTranslationCallbackCall(path, called) {
+        if (called?.kind !== "api" || called.api !== "Translation") {
+            return;
+        }
+        const props = callArguments(path)[0];
+        const info = normalizedInfo(staticNamespaces(objectProperty(props, "ns"), this.file), staticKeyPrefix(objectProperty(props, "keyPrefix"), this.file));
+        this.markTranslationCallback(objectProperty(props, "children"), info);
+    }
+    registerInitCallback(path, called) {
+        if (called?.kind !== "api" || called.api !== "init") {
+            return;
+        }
+        const callback = callArguments(path).findLast((argument) => this.resolveFunction(argument) !== undefined);
+        const fn = this.resolveFunction(callback);
+        if (fn !== undefined && !fn.isClass()) {
+            this.registerTParameter(fn, 1, GLOBAL_T);
+        }
+    }
+    registerInitPromiseCallback(path, callee) {
+        if (callee === undefined) {
+            return;
+        }
+        if (memberProperty(callee) !== "then") {
+            return;
+        }
+        const receiver = oneChild(unwrapPath(callee), "object");
+        const received = receiver === undefined ? undefined : this.resolvePath(receiver);
+        if (received?.kind !== "initPromise") {
+            return;
+        }
+        this.registerInitPromiseFunction(this.resolveFunction(callArguments(path)[0]));
+    }
+    registerInitPromiseFunction(fn) {
+        if (fn === undefined || fn.isClass()) {
+            return;
+        }
+        this.registerTParameter(fn, 0, GLOBAL_T);
+    }
+    registerCallableComponent(path, called) {
+        if (called?.kind !== "api") {
+            return;
+        }
+        if (["IcuTrans", "IcuTransWithoutContext"].includes(called.api)) {
+            this.addComponentMessage(this.callableIcuInput(path));
+        }
+        if (["Trans", "TransWithoutContext"].includes(called.api)) {
+            this.addComponentMessage(this.callableTransInput(path));
+        }
+    }
+    callableIcuInput(path) {
+        const props = callArguments(path)[0];
+        return {
+            defaultPath: objectProperty(props, "defaultTranslation"),
+            isIcu: true,
+            keyPath: objectProperty(props, "i18nKey"),
+            namespacePath: objectProperty(props, "ns"),
+            path,
+            tPath: objectProperty(props, "t"),
+            valuesPath: objectProperty(props, "values"),
+        };
+    }
+    callableTransInput(path) {
+        const props = callArguments(path)[0];
+        return {
+            contextPath: objectProperty(props, "context"),
+            countPath: objectProperty(props, "count"),
+            defaultPath: objectProperty(props, "defaults") ?? objectProperty(props, "children"),
+            isIcu: false,
+            keyPath: objectProperty(props, "i18nKey"),
+            namespacePath: objectProperty(props, "ns"),
+            optionsPath: objectProperty(props, "tOptions"),
+            path,
+            tPath: objectProperty(props, "t"),
+            valuesPath: objectProperty(props, "values"),
+        };
+    }
+    registerBlockedGetFixedT(path) {
+        const callee = this.possibleGetFixedCallee(path);
+        if (callee === undefined) {
+            return;
+        }
+        const semantic = this.resolvePath(callee);
+        if (this.isGetFixedApi(semantic)) {
+            return;
+        }
+        const key = spanKey(path.node);
+        if (key !== undefined) {
+            this.blockedGetFixedT.add(key);
+        }
+    }
+    possibleGetFixedCallee(path) {
+        const init = oneChild(path, "init");
+        if (!init?.isCallExpression()) {
+            return;
+        }
+        const callee = oneChild(init, "callee");
+        return callee !== undefined && memberProperty(callee) === "getFixedT"
+            ? callee
+            : undefined;
+    }
+    isGetFixedApi(semantic) {
+        return semantic?.kind === "api" && semantic.api === "getFixedT";
+    }
+    registerJsxElement(path) {
+        const opening = oneChild(path, "openingElement");
+        const name = opening === undefined ? undefined : oneChild(opening, "name");
+        const component = name === undefined ? undefined : this.jsxSemantic(name);
+        if (opening === undefined || component?.kind !== "api") {
+            return;
+        }
+        this.registerApiJsx(path, opening, component.api);
+    }
+    registerApiJsx(path, opening, api) {
+        if (["Trans", "TransWithoutContext"].includes(api)) {
+            this.registerTransJsx(path, opening);
+            return;
+        }
+        if (api === "Translation") {
+            this.registerTranslationJsx(path);
+            return;
+        }
+        if (["IcuTrans", "IcuTransWithoutContext"].includes(api)) {
+            this.addComponentMessage(this.jsxIcuInput(path));
+        }
+    }
+    registerTransJsx(path, opening) {
+        if (!this.validateTransJsxProps(path, opening)) {
+            return;
+        }
+        const key = spanKey(path.node);
+        if (key === undefined) {
+            return;
+        }
+        const scope = this.transJsxScope(path);
+        if (!scope.isValid) {
+            return;
+        }
+        this.trans.set(key, scope.value ?? null);
+    }
+    validateTransJsxProps(path, opening) {
+        const hasSpread = childPaths(opening, "attributes").some((attribute) => attribute.isJSXSpreadAttribute());
+        if (hasSpread) {
+            this.errors.add(`Trans JSX props must be written explicitly for static extraction in ${this.file}`);
+            return false;
+        }
+        if (isStaticStringArray(this.jsxAttribute(path, "i18nKey"))) {
+            this.errors.add(`Trans JSX i18nKey arrays are not supported by static extraction in ${this.file}`);
+            return false;
+        }
+        return true;
+    }
+    transJsxScope(path) {
+        const tProp = this.jsxAttribute(path, "t");
+        if (tProp === undefined) {
+            return { isValid: true };
+        }
+        const semantic = this.resolvePath(tProp);
+        if (semantic?.kind !== "t") {
+            this.errors.add(`Trans t props must have a statically known scope in ${this.file}`);
+            return { isValid: false };
+        }
+        if (!this.validatePrefixedTransNamespace(path, semantic)) {
+            return { isValid: false };
+        }
+        return { isValid: true, value: semantic.info };
+    }
+    validatePrefixedTransNamespace(path, t) {
+        if (t.info.keyPrefix === undefined || this.jsxAttribute(path, "ns") === undefined) {
+            return true;
+        }
+        this.errors.add(`Prefixed Trans components cannot also override ns during static extraction in ${this.file}`);
+        return false;
+    }
+    registerTranslationJsx(path) {
+        const info = this.scopeFromJsx(path);
+        this.markTranslationCallback(this.jsxAttribute(path, "children"), info);
+        for (const child of childPaths(path, "children")) {
+            if (child.isJSXExpressionContainer()) {
+                this.markTranslationCallback(oneChild(child, "expression"), info);
+            }
+        }
+    }
+    jsxIcuInput(path) {
+        return {
+            defaultPath: this.jsxAttribute(path, "defaultTranslation"),
+            isIcu: true,
+            keyPath: this.jsxAttribute(path, "i18nKey"),
+            namespacePath: this.jsxAttribute(path, "ns"),
+            path,
+            tPath: this.jsxAttribute(path, "t"),
+            valuesPath: this.jsxAttribute(path, "values"),
+        };
+    }
+    classT(callee) {
+        if (memberProperty(callee) !== "t") {
+            return;
+        }
+        const object = oneChild(unwrapPath(callee), "object");
+        if (object === undefined || memberProperty(object) !== "props") {
+            return;
+        }
+        const receiver = oneChild(unwrapPath(object), "object");
+        if (receiver?.isThisExpression() !== true) {
+            return;
+        }
+        const owner = callee.findParent(isClassPath);
+        return owner === null ? undefined : this.hocClasses.get(owner.node);
+    }
+    optionsKeyPrefix(call) {
+        for (const argument of callArguments(call).slice(1)) {
+            const keyPrefix = objectProperty(argument, "keyPrefix");
+            if (keyPrefix !== undefined) {
+                return keyPrefix;
+            }
+        }
+        return undefined;
+    }
+    registerTranslationCall(path) {
+        const callee = oneChild(path, "callee");
+        if (callee === undefined) {
+            return;
+        }
+        const resolved = this.resolvePath(callee);
+        const t = resolved?.kind === "t" ? resolved : this.classT(callee);
+        const key = spanKey(path.node);
+        if (t === undefined || key === undefined) {
+            return;
+        }
+        const info = this.translationCallScope(path, t);
+        if (info !== undefined) {
+            this.calls.set(key, { info, key });
+        }
+    }
+    translationCallScope(path, t) {
+        const keyPrefix = this.optionsKeyPrefix(path);
+        if (keyPrefix === undefined) {
+            return t.info;
+        }
+        const literalPrefix = literalString(keyPrefix);
+        if (literalPrefix === undefined) {
+            this.errors.add(`Translation keyPrefix options must be static strings in ${this.file}`);
+            return;
+        }
+        if (!t.fixed) {
+            this.errors.add(`keyPrefix options require a fixed translation function in ${this.file}`);
+            return;
+        }
+        return scopeWithPrefix(t.info, literalPrefix);
+    }
+    registerTaggedTranslation(path) {
+        const tag = oneChild(path, "tag");
+        const resolved = tag === undefined ? undefined : this.resolvePath(tag);
+        if (resolved?.kind === "t") {
+            this.errors.add(`Tagged-template translations are not compatible with strict GTKX codegen in ${this.file}`);
+        }
+    }
+    analyze(program) {
+        this.runSemanticPass(program);
+        this.bindingCache.clear();
+        this.runTranslationPass(program);
+        return {
+            blockedGetFixedT: this.blockedGetFixedT,
+            calls: this.calls,
+            errors: [...this.errors],
+            messages: this.messages,
+            trans: this.trans,
+        };
+    }
+}
+export { extractBindings };
+//# sourceMappingURL=binding-extractor.js.map