@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/dist/i18n/binding-extractor.js

@@ -1,1324 +0,0 @@
-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