gtx-cli 2.3.5 → 2.3.6-alpha.2

package/dist/react/jsx/utils/validateStringFunction.js

@@ -1,31 +0,0 @@
-import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
-import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, } from './constants.js';
-/**
- * Validate useGT() / await getGT() calls
- * 1. Validates that the call does not violate the rules of React (no hooks in async functions)
- */
-export function validateStringFunction(localImportName, path, updates, errors, file, originalImportName) {
-    // Get the root program node to traverse the entire file
-    const program = path.scope.getProgramParent().path;
-    program.traverse({
-        CallExpression(callPath) {
-            if (callPath.node.callee.type === 'Identifier' &&
-                callPath.node.callee.name === localImportName) {
-                // Check the function scope
-                const functionScope = callPath.getFunctionParent();
-                if (originalImportName === INLINE_TRANSLATION_HOOK) {
-                    // useGT should NOT be in an async function
-                    if (functionScope && functionScope.node.async) {
-                        errors.push(warnAsyncUseGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
-                    }
-                }
-                else if (originalImportName === INLINE_TRANSLATION_HOOK_ASYNC) {
-                    // getGT should be in an async function
-                    if (!functionScope || !functionScope.node.async) {
-                        errors.push(warnSyncGetGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
-                    }
-                }
-            }
-        },
-    });
-}

package/dist/react/jsx/wrapJsx.d.ts

@@ -1,51 +0,0 @@
-import * as t from '@babel/types';
-import { ImportItem } from './utils/parseAst.js';
-/**
- * Recursively wraps a JSX element with a <T> component and unique id
- * @param node - The JSX element to wrap
- * @param updates - The updates array
- * @param errors - The errors array
- * @param file - The file name
- * @param options - Optional component names for T and Var
- */
-export interface WrapResult {
-    node: t.JSXElement | t.JSXFragment;
-    hasMeaningfulContent: boolean;
-    wrappedInT: boolean;
-}
-/**
- * Recursively traverse a JSX element and wrap variables with a <Var> component
- * @param node - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export declare function wrapJsxElement(node: t.JSXElement | t.JSXFragment, options: {
-    createIds: boolean;
-    TComponent?: string;
-    VarComponent?: string;
-    idPrefix: string;
-    idCount: number;
-    usedImports: ImportItem[];
-    modified: boolean;
-    warnings: string[];
-    file: string;
-}, isMeaningful: (node: t.Node) => boolean, mark: boolean): WrapResult;
-/**
- * Wraps a JSX element with a <T> component and unique id
- * @param rootNode - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export declare function handleJsxElement(rootNode: t.JSXElement | t.JSXFragment, options: {
-    createIds: boolean;
-    usedImports: ImportItem[];
-    TComponent?: string;
-    VarComponent?: string;
-    idPrefix: string;
-    idCount: number;
-    modified: boolean;
-    warnings: string[];
-    file: string;
-}, isMeaningful: (node: t.Node) => boolean): WrapResult;

package/dist/react/jsx/wrapJsx.js

@@ -1,387 +0,0 @@
-import * as t from '@babel/types';
-import { isStaticExpression, isStaticValue } from './evaluateJsx.js';
-import { warnTernarySync } from '../../console/index.js';
-function wrapJsxExpression(node, options, isMeaningful, mark) {
-    const expression = t.isParenthesizedExpression(node.expression)
-        ? node.expression.expression
-        : node.expression;
-    // Ignore template literals containing quasis - they should not be counted as meaningful
-    if (t.isTemplateLiteral(expression) && expression.expressions.length > 0) {
-        return {
-            node,
-            hasMeaningfulContent: false,
-            wrappedInT: false,
-        };
-    }
-    // Handle both JSX Elements and Fragments
-    if (t.isJSXElement(expression) ||
-        t.isJSXFragment(expression) ||
-        t.isStringLiteral(expression) ||
-        t.isJSXText(expression) ||
-        t.isTemplateLiteral(expression)) {
-        if (t.isJSXElement(expression) || t.isJSXFragment(expression)) {
-            const result = wrapJsxElement(expression, options, isMeaningful, mark);
-            // re-wrap the result in a JSXExpressionContainer
-            if (t.isParenthesizedExpression(node.expression)) {
-                node.expression.expression = result.node;
-            }
-            else {
-                node.expression = result.node;
-            }
-            return {
-                node,
-                hasMeaningfulContent: result.hasMeaningfulContent,
-                wrappedInT: result.wrappedInT,
-            };
-        }
-        return {
-            node,
-            hasMeaningfulContent: isMeaningful(expression),
-            wrappedInT: false,
-        };
-    }
-    // Handle conditional expressions (ternary)
-    else if (t.isConditionalExpression(expression)) {
-        const consequent = t.isParenthesizedExpression(expression.consequent)
-            ? expression.consequent.expression
-            : expression.consequent;
-        const alternate = t.isParenthesizedExpression(expression.alternate)
-            ? expression.alternate.expression
-            : expression.alternate;
-        // Handle consequent
-        if (t.isJSXElement(consequent) || t.isJSXFragment(consequent)) {
-            const result = handleJsxElement(consequent, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.consequent)) {
-                expression.consequent.expression = result.node;
-            }
-            else {
-                expression.consequent = result.node;
-            }
-            // Warn about ternary (should use branch instead)
-            if (result.wrappedInT && !mark) {
-                options.warnings.push(warnTernarySync(options.file, `${consequent.loc?.start?.line}:${consequent.loc?.start?.column}`));
-            }
-        }
-        else if (t.isConditionalExpression(consequent) ||
-            t.isLogicalExpression(consequent)) {
-            // Recursively handle nested ternary in consequent
-            const consequentResult = wrapJsxExpression(t.jsxExpressionContainer(consequent), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(consequentResult.node) &&
-                t.isExpression(consequentResult.node.expression)) {
-                expression.consequent = consequentResult.node.expression;
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.consequent)) {
-                    expression.consequent.expression = consequentResult.node.expression;
-                }
-                else {
-                    expression.consequent = consequentResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(consequent) &&
-            consequent.expressions.length > 0) {
-            // Ignore template literals in consequent with expressions (${}), don't wrap them
-            // Do nothing
-        }
-        else {
-            if (isStaticValue(consequent) && isMeaningful(consequent)) {
-                const wrapped = wrapExpressionWithT(consequent, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.consequent)) {
-                    expression.consequent.expression = wrapped;
-                }
-                else {
-                    expression.consequent = wrapped;
-                }
-            }
-        }
-        // Handle alternate
-        if (t.isJSXElement(alternate) || t.isJSXFragment(alternate)) {
-            const result = handleJsxElement(alternate, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.alternate)) {
-                expression.alternate.expression = result.node;
-            }
-            else {
-                expression.alternate = result.node;
-            }
-        }
-        else if (t.isConditionalExpression(alternate) ||
-            t.isLogicalExpression(alternate)) {
-            // Recursively handle nested ternary in alternate
-            const alternateResult = wrapJsxExpression(t.jsxExpressionContainer(alternate), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(alternateResult.node) &&
-                t.isExpression(alternateResult.node.expression)) {
-                expression.alternate = alternateResult.node.expression;
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.alternate)) {
-                    expression.alternate.expression = alternateResult.node.expression;
-                }
-                else {
-                    expression.alternate = alternateResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(alternate) &&
-            alternate.expressions.length > 0) {
-            // Ignore template literals in alternate with expressions (${}), don't wrap them
-            // Do nothing
-        }
-        else {
-            if (isStaticValue(alternate) && isMeaningful(alternate)) {
-                const wrapped = wrapExpressionWithT(alternate, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.alternate)) {
-                    expression.alternate.expression = wrapped;
-                }
-                else {
-                    expression.alternate = wrapped;
-                }
-            }
-        }
-    }
-    // Handle logical expressions (&& and ||)
-    else if (t.isLogicalExpression(expression)) {
-        const left = t.isParenthesizedExpression(expression.left)
-            ? expression.left.expression
-            : expression.left;
-        const right = t.isParenthesizedExpression(expression.right)
-            ? expression.right.expression
-            : expression.right;
-        if (t.isJSXElement(left) || t.isJSXFragment(left)) {
-            const result = handleJsxElement(left, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.left)) {
-                expression.left.expression = result.node;
-            }
-            else {
-                expression.left = result.node;
-            }
-        }
-        else if (t.isLogicalExpression(left) || t.isConditionalExpression(left)) {
-            // Recursively handle nested logical expressions
-            const leftResult = wrapJsxExpression(t.jsxExpressionContainer(left), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(leftResult.node) &&
-                t.isExpression(leftResult.node.expression)) {
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.left)) {
-                    expression.left.expression = leftResult.node.expression;
-                }
-                else {
-                    expression.left = leftResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(left) && left.expressions.length > 0) {
-            // Ignore template literals with expressions (${}) in left side of logical expression
-            // Do nothing - don't wrap them
-        }
-        else {
-            if (isStaticValue(left) &&
-                isMeaningful(left) &&
-                expression.operator !== '&&') {
-                const wrapped = wrapExpressionWithT(left, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.left)) {
-                    expression.left.expression = wrapped;
-                }
-                else {
-                    expression.left = wrapped;
-                }
-            }
-        }
-        if (t.isJSXElement(right) || t.isJSXFragment(right)) {
-            const result = handleJsxElement(right, options, isMeaningful);
-            // Re-insert into parenthesized expression if necessary
-            if (t.isParenthesizedExpression(expression.right)) {
-                expression.right.expression = result.node;
-            }
-            else {
-                expression.right = result.node;
-            }
-        }
-        else if (t.isLogicalExpression(right) ||
-            t.isConditionalExpression(right)) {
-            // Recursively handle nested logical expressions
-            const rightResult = wrapJsxExpression(t.jsxExpressionContainer(right), options, isMeaningful, mark);
-            if (t.isJSXExpressionContainer(rightResult.node) &&
-                t.isExpression(rightResult.node.expression)) {
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.right)) {
-                    expression.right.expression = rightResult.node.expression;
-                }
-                else {
-                    expression.right = rightResult.node.expression;
-                }
-            }
-        }
-        else if (t.isTemplateLiteral(right) && right.expressions.length > 0) {
-            // Ignore template literals with expressions (${}) in right side of logical expression
-            // Do nothing - don't wrap them
-        }
-        else {
-            if (isStaticValue(right) &&
-                isMeaningful(right) &&
-                expression.operator !== '||') {
-                const wrapped = wrapExpressionWithT(right, options, false);
-                // Re-insert into parenthesized expression if necessary
-                if (t.isParenthesizedExpression(expression.right)) {
-                    expression.right.expression = wrapped;
-                }
-                else {
-                    expression.right = wrapped;
-                }
-            }
-        }
-    }
-    const staticCheck = isStaticExpression(expression);
-    // If the expression is not static or if it's already wrapped in T,
-    // wrap with Var
-    if (!staticCheck.isStatic) {
-        return {
-            node: wrapWithVar(node, options, mark),
-            hasMeaningfulContent: false,
-            wrappedInT: false,
-        };
-    }
-    // If it's a static expression, check if it's meaningful
-    return {
-        node,
-        hasMeaningfulContent: false,
-        wrappedInT: false,
-    };
-}
-/**
- * Recursively traverse a JSX element and wrap variables with a <Var> component
- * @param node - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export function wrapJsxElement(node, options, isMeaningful, mark) {
-    const TComponentName = options.TComponent || 'T';
-    const VarComponentName = options.VarComponent || 'Var';
-    // Handle both JSX Elements and Fragments
-    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
-        // For elements, check if it's already a T or Var component
-        if (t.isJSXElement(node)) {
-            const name = node.openingElement.name;
-            if (t.isJSXIdentifier(name) &&
-                (name.name === TComponentName || name.name === VarComponentName)) {
-                return {
-                    node,
-                    hasMeaningfulContent: false,
-                    wrappedInT: name.name === TComponentName,
-                };
-            }
-        }
-        // Process children recursively (DFS postorder)
-        let hasMeaningfulContent = false;
-        let wrappedInT = false;
-        const processedChildren = node.children.map((child) => {
-            if (t.isJSXElement(child) || t.isJSXFragment(child)) {
-                const result = wrapJsxElement(child, options, isMeaningful, mark);
-                hasMeaningfulContent =
-                    hasMeaningfulContent || result.hasMeaningfulContent;
-                wrappedInT = wrappedInT || result.wrappedInT;
-                return result.node;
-            }
-            if (t.isJSXExpressionContainer(child)) {
-                const result = wrapJsxExpression(child, options, isMeaningful, mark);
-                wrappedInT = wrappedInT || result.wrappedInT;
-                hasMeaningfulContent =
-                    hasMeaningfulContent || result.hasMeaningfulContent;
-                // Expressions are never meaningful because they will either:
-                // 1. be sub-wrapped in a T (if they contain meaningful content)
-                // 2. be wrapped in a Var (if they are not static)
-                return result.node;
-            }
-            const isMeaningfulVal = isMeaningful(child);
-            if (isMeaningfulVal) {
-                hasMeaningfulContent = true;
-            }
-            return child;
-        });
-        node.children = processedChildren;
-        return {
-            node,
-            hasMeaningfulContent: hasMeaningfulContent,
-            wrappedInT: wrappedInT,
-        };
-    }
-    // For any other node types, return as-is
-    return {
-        node,
-        hasMeaningfulContent: false,
-        wrappedInT: false,
-    };
-}
-/**
- * Wraps a JSX element with a <T> component and unique id
- * @param rootNode - The JSX element to wrap
- * @param options - Optional component names for T and Var
- * @param isMeaningful - A function to determine if a node is meaningful
- * @returns The wrapped JSX element
- */
-export function handleJsxElement(rootNode, options, isMeaningful) {
-    const result = wrapJsxElement(rootNode, options, isMeaningful, true);
-    // Only wrap with T at the root level if there's meaningful content
-    if (result.hasMeaningfulContent) {
-        const output = wrapJsxElement(result.node, options, isMeaningful, false);
-        const node = wrapWithT(output.node, options, false);
-        return {
-            node,
-            hasMeaningfulContent: true,
-            wrappedInT: true,
-        };
-    }
-    return {
-        node: result.node,
-        hasMeaningfulContent: false,
-        wrappedInT: result.wrappedInT,
-    };
-}
-function wrapWithT(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const TComponentName = options.TComponent || 'T';
-    const uniqueId = `${options.idPrefix}.${options.idCount}`;
-    options.modified = true;
-    options.idCount++;
-    if (!options.usedImports.includes(TComponentName)) {
-        options.usedImports.push(TComponentName);
-    }
-    if (options.createIds) {
-        return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [node], false);
-}
-function wrapExpressionWithT(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const TComponentName = options.TComponent || 'T';
-    const uniqueId = `${options.idPrefix}.${options.idCount}`;
-    options.modified = true;
-    options.idCount++;
-    if (!options.usedImports.includes(TComponentName)) {
-        options.usedImports.push(TComponentName);
-    }
-    if (options.createIds) {
-        return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(uniqueId))], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(TComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(TComponentName)), [t.jsxExpressionContainer(node)], false);
-}
-function wrapWithVar(node, options, mark) {
-    if (mark) {
-        return node;
-    }
-    const VarComponentName = options.VarComponent || 'Var';
-    options.modified = true;
-    if (!options.usedImports.includes(VarComponentName)) {
-        options.usedImports.push(VarComponentName);
-    }
-    return t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(VarComponentName), [], false), t.jsxClosingElement(t.jsxIdentifier(VarComponentName)), [node], false);
-}

package/dist/react/parse/createDictionaryUpdates.d.ts

@@ -1,3 +0,0 @@
-import { BuildOptions } from 'esbuild';
-import { Updates } from '../../types/index.js';
-export declare function createDictionaryUpdates(dictionaryPath: string, esbuildConfig?: BuildOptions): Promise<Updates>;

package/dist/react/parse/createDictionaryUpdates.js

@@ -1,169 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'os';
-import { build } from 'esbuild';
-import flattenDictionary from '../utils/flattenDictionary.js';
-import loadJSON from '../../fs/loadJSON.js';
-import { hashSource } from 'generaltranslation/id';
-import getEntryAndMetadata from '../utils/getEntryAndMetadata.js';
-import { logError } from '../../console/logging.js';
-import { randomUUID } from 'node:crypto';
-export async function createDictionaryUpdates(dictionaryPath, esbuildConfig) {
-    let dictionary;
-    // ---- HANDLE JSON STRING DICTIONARY ----- //
-    if (dictionaryPath.endsWith('.json')) {
-        dictionary = flattenDictionary(loadJSON(dictionaryPath) || {});
-    }
-    // ----- HANDLE REACT DICTIONARY ---- //
-    else {
-        const result = await build({
-            ...esbuildConfig,
-            entryPoints: [dictionaryPath],
-            write: false,
-        });
-        const bundledCode = result.outputFiles[0].text;
-        const tempFilePath = path.join(os.tmpdir(), `bundled-dictionary-${randomUUID()}.js`);
-        await fs.promises.writeFile(tempFilePath, bundledCode);
-        // Load the module using dynamic import
-        let dictionaryModule;
-        try {
-            dictionaryModule = await import(tempFilePath);
-        }
-        catch (error) {
-            logError(`Failed to load the bundled dictionary code: ${error}`);
-            process.exit(1);
-        }
-        finally {
-            // Clean up the temporary file
-            await fs.promises.unlink(tempFilePath);
-        }
-        const unwrappedDictionary = unwrapDictionaryModule(dictionaryModule);
-        dictionary = flattenDictionary(unwrappedDictionary);
-    }
-    // ----- CREATE PARTIAL UPDATES ----- //
-    const updates = [];
-    for (const id of Object.keys(dictionary)) {
-        const { entry, metadata: props, // context, etc.
-         } = getEntryAndMetadata(dictionary[id]);
-        // Map $context to context
-        const context = props?.$context;
-        const metadata = {
-            id,
-            ...(context && { context }),
-            // This hash isn't actually used by the GT API, just for consistency sake
-            hash: hashSource({
-                source: entry,
-                ...(context && { context }),
-                ...(id && { id }),
-                dataFormat: 'ICU',
-            }),
-        };
-        updates.push({
-            dataFormat: 'ICU',
-            source: entry,
-            metadata,
-        });
-    }
-    return updates;
-}
-function unwrapDictionaryModule(mod) {
-    let current = mod;
-    // Keep unwrapping until we get to the actual dictionary
-    while (current && typeof current === 'object') {
-        const keys = Object.keys(current);
-        // Check if this looks like a module namespace object (has only module-related keys)
-        const isModuleNamespace = keys.every((key) => key === 'default' || key === 'module.exports' || key === '__esModule');
-        // Check if this is a module with named exports (has 'dictionary' export)
-        // Only check for named exports if it's NOT a pure module namespace
-        const hasNamedDictionary = !isModuleNamespace &&
-            'dictionary' in current &&
-            current.dictionary &&
-            typeof current.dictionary === 'object' &&
-            !Array.isArray(current.dictionary);
-        if (hasNamedDictionary) {
-            // If there's a named 'dictionary' export, use that
-            return current.dictionary;
-        }
-        else if (isModuleNamespace) {
-            // Try to get the default export
-            if ('default' in current) {
-                let result = current.default;
-                // If the default export is a function (getter), call it
-                if (typeof result === 'function') {
-                    try {
-                        result = result();
-                    }
-                    catch {
-                        // If calling fails, break the loop
-                        break;
-                    }
-                }
-                // If we have a valid object, check if we should continue unwrapping
-                if (result && typeof result === 'object' && !Array.isArray(result)) {
-                    const resultKeys = Object.keys(result);
-                    // Only continue unwrapping if this looks like a getter-based module layer
-                    // We should NOT continue if this is just a user dictionary with a 'default' property
-                    const hasGetterProperties = resultKeys.some((key) => {
-                        try {
-                            const descriptor = Object.getOwnPropertyDescriptor(result, key);
-                            return descriptor && typeof descriptor.get === 'function';
-                        }
-                        catch {
-                            return false;
-                        }
-                    });
-                    if (hasGetterProperties) {
-                        current = result;
-                        continue;
-                    }
-                    else {
-                        // This is the actual dictionary, return it
-                        return result;
-                    }
-                }
-            }
-            // Try module.exports as fallback
-            if ('module.exports' in current) {
-                let result = current['module.exports'];
-                if (typeof result === 'function') {
-                    try {
-                        result = result();
-                    }
-                    catch {
-                        // If calling fails, break the loop
-                        break;
-                    }
-                }
-                if (result && typeof result === 'object' && !Array.isArray(result)) {
-                    const resultKeys = Object.keys(result);
-                    // Only continue unwrapping if this looks like a getter-based module layer
-                    // We should NOT continue if this is just a user dictionary with a 'default' property
-                    const hasGetterProperties = resultKeys.some((key) => {
-                        try {
-                            const descriptor = Object.getOwnPropertyDescriptor(result, key);
-                            return descriptor && typeof descriptor.get === 'function';
-                        }
-                        catch {
-                            return false;
-                        }
-                    });
-                    if (hasGetterProperties) {
-                        current = result;
-                        continue;
-                    }
-                    else {
-                        // This is the actual dictionary, return it
-                        return result;
-                    }
-                }
-            }
-            // If we can't unwrap further, break
-            break;
-        }
-        else {
-            // This appears to be the actual dictionary object, not a module wrapper
-            break;
-        }
-    }
-    return current || {};
-}

package/dist/react/parse/createInlineUpdates.d.ts

@@ -1,6 +0,0 @@
-import { Updates } from '../../types/index.js';
-export declare function createInlineUpdates(pkg: 'gt-react' | 'gt-next', validate: boolean, filePatterns: string[] | undefined): Promise<{
-    updates: Updates;
-    errors: string[];
-    warnings: string[];
-}>;