gt-next 2.0.2 → 2.0.4

package/dist/server/rendering/renderTranslatedChildren.js

@@ -1,233 +0,0 @@
-"use strict";
-/*import React, { ReactElement, ReactNode } from 'react';
-import {
-  TranslatedChildren,
-  TranslatedElement,
-  VariableObject,
-} from 'gt-react/dist/primitives/types';
-import {
-  isVariableObject,
-  getVariableProps,
-  getPluralBranch,
-} from 'gt-react/internal';
-import { libraryDefaultLocale } from 'generaltranslation/internal';
-import getGTProp from '../../utils/getGTProp';
-import renderVariable from './renderVariable';
-
-function renderTranslatedElement({
-  sourceElement,
-  targetElement,
-  variables = {},
-  variablesOptions = {},
-  locales = [libraryDefaultLocale],
-}: {
-  sourceElement: ReactElement;
-  targetElement: TranslatedElement;
-  variables?: Record<string, any>;
-  variablesOptions?: Record<string, any>;
-  locales: string[];
-}) {
-  const {
-    props: { 'data-_gt': generaltranslation, ...props },
-  } = sourceElement;
-
-  const transformation = generaltranslation?.['transformation'];
-
-  if (transformation === 'plural') {
-    const n =
-      typeof variables.n === 'number'
-        ? variables.n
-        : typeof sourceElement.props.n === 'number'
-        ? sourceElement.props.n
-        : sourceElement.props['data-_gt-n'];
-    const sourceBranches = generaltranslation.branches || {};
-    const sourceBranch =
-      getPluralBranch(n, locales, sourceBranches) ||
-      sourceElement.props.children;
-    const targetBranches = targetElement.props['data-_gt'].branches || {};
-    const targetBranch =
-      getPluralBranch(n, locales, targetBranches) ||
-      targetElement.props.children;
-    return renderTranslatedChildren({
-      source: sourceBranch,
-      target: targetBranch,
-      variables,
-      variablesOptions,
-      locales,
-    });
-  }
-
-  if (transformation === 'branch') {
-    let { name, branch, children } = props;
-    name = name || sourceElement.props['data-_gt-name'] || 'branch';
-    branch =
-      variables[name] || branch || sourceElement.props['data-_gt-branch-name'];
-    const sourceBranch =
-      (generaltranslation.branches || {})[branch] || children;
-    const targetBranch =
-      (targetElement.props['data-_gt'].branches || {})[branch] ||
-      targetElement.props.children;
-    return renderTranslatedChildren({
-      source: sourceBranch,
-      target: targetBranch,
-      variables,
-      variablesOptions,
-      locales,
-    });
-  }
-
-  // If there are children, clone the source element with new children that represent the translation
-  if (props?.children && targetElement.props?.children) {
-    return React.cloneElement(sourceElement, {
-      ...props,
-      'data-_gt': undefined,
-      children: renderTranslatedChildren({
-        source: props.children,
-        target: targetElement.props.children,
-        variables,
-        variablesOptions,
-        locales,
-      }),
-    });
-  }
-
-  return sourceElement;
-}
-
-export default function renderTranslatedChildren({
-  source,
-  target,
-  variables = {},
-  variablesOptions = {},
-  locales = [libraryDefaultLocale],
-}: {
-  source: ReactNode;
-  target: TranslatedChildren;
-  variables?: Record<string, any>;
-  variablesOptions?: Record<string, any>;
-  locales: string[];
-}): ReactNode {
-  // Most straightforward case, return a valid React node
-  // If there is an error in the translation or similar, return the default
-  if ((target === null || typeof target === 'undefined') && source)
-    return source;
-  if (typeof target === 'string') return target;
-
-  // Source & target are both arrays, but may be in different orders
-  // Go through the source array & filters the source elements for actual react elements & variables
-  if (Array.isArray(source) && Array.isArray(target)) {
-    const sourceElements: ReactElement[] = source.filter((sourceChild) => {
-      if (React.isValidElement(sourceChild)) {
-        const generaltranslation = getGTProp(sourceChild);
-        if (generaltranslation?.transformation === 'variable') {
-          let { variableName, variableValue, variableOptions } =
-            getVariableProps(sourceChild.props as any);
-          if (typeof variables[variableName] === 'undefined') {
-            variables[variableName] = variableValue;
-          }
-          variablesOptions[variableName] = {
-            ...variablesOptions[variableName],
-            ...variableOptions,
-          };
-        } else {
-          return true;
-        }
-      }
-    });
-
-    // Take a target element & find the matching source element with the same id
-    const findMatchingSourceElement = (
-      targetElement: TranslatedElement
-    ): ReactElement | undefined => {
-      return sourceElements.find((sourceChild) => {
-        const generaltranslation = getGTProp(sourceChild);
-        if (typeof generaltranslation?.id !== 'undefined') {
-          const sourceID = generaltranslation.id;
-          const targetID = targetElement?.props?.['data-_gt']?.id;
-          return sourceID === targetID;
-        }
-        return false;
-      });
-    };
-
-    // Iterate through the target array & recursively render the translated children
-    return target.map((targetChild, index) => {
-      if (typeof targetChild === 'string')
-        return (
-          <React.Fragment key={`string_${index}`}>{targetChild}</React.Fragment>
-        );
-      if (isVariableObject(targetChild)) {
-        return (
-          <React.Fragment key={`var_${index}`}>
-            {renderVariable({
-              variableType: targetChild.variable || 'variable',
-              variableName: targetChild.key,
-              variableValue: variables[targetChild.key],
-              variableOptions: variablesOptions[targetChild.key],
-            })}
-          </React.Fragment>
-        );
-      }
-      const matchingSourceElement = findMatchingSourceElement(targetChild);
-      if (matchingSourceElement)
-        return (
-          <React.Fragment key={`element_${index}`}>
-            {renderTranslatedElement({
-              sourceElement: matchingSourceElement,
-              targetElement: targetChild,
-              variables,
-              variablesOptions,
-              locales,
-            })}
-          </React.Fragment>
-        );
-    });
-  }
-
-  if (target && typeof target === 'object' && !Array.isArray(target)) {
-    const targetType: 'variable' | 'element' = isVariableObject(target)
-      ? 'variable'
-      : 'element';
-
-    if (React.isValidElement(source)) {
-      if (targetType === 'element') {
-        return renderTranslatedElement({
-          sourceElement: source,
-          targetElement: target as TranslatedElement,
-          variables,
-          variablesOptions,
-          locales,
-        });
-      }
-
-      const generaltranslation = getGTProp(source);
-      if (generaltranslation?.transformation === 'variable') {
-        let { variableName, variableValue, variableOptions } = getVariableProps(
-          source.props
-        );
-
-        if (typeof variables[variableName] === 'undefined') {
-          variables[variableName] = variableValue;
-        }
-        variablesOptions[variableName] = {
-          ...variablesOptions[variableName],
-          ...variableOptions,
-        };
-      }
-    }
-
-    if (targetType === 'variable') {
-      const targetVariable = target as VariableObject;
-      return renderVariable({
-        variableType: targetVariable.variable || 'variable',
-        variableName: targetVariable.key,
-        variableValue: variables[targetVariable.key],
-        variableOptions: variablesOptions[targetVariable.key],
-      });
-    }
-  }
-
-  return source;
-}
-*/ 
-//# sourceMappingURL=renderTranslatedChildren.js.map

package/dist/server/rendering/renderTranslatedChildren.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"renderTranslatedChildren.js","sourceRoot":"","sources":["../../../src/server/rendering/renderTranslatedChildren.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsOE"}