@qrvey/utils 1.2.7 → 1.2.9-2

package/src/globalization/labels/formula_builder/I18N_FORMULA_BUILDER.ts

@@ -0,0 +1,432 @@
+import { II18nFormulaBuilder } from "../../interfaces/formula_builder";
+
+export const I18N_FORMULA_BUILDER: II18nFormulaBuilder = {
+    list_modal: {
+        title_header: 'Formulas',
+        create_button: 'Create Formula',
+        empty_message: 'No Formulas Yet'
+    },
+    list_table: {
+        name: 'Formula Name',
+        formula: 'Formula',
+        menu_edit: 'Edit',
+        menu_duplicate: 'Duplicate',
+        menu_delete: 'Delete',
+        duplicate_copy: 'Copy',
+        duplicate_toast: 'Formula Successfully Duplicated'
+    },
+    delete_dialog: {
+        title: 'Delete Formula',
+        description: 'Deleting this formula will remove all instances of this calculation in your analytics.',
+        toast_description: 'Formula Successfully Deleted',
+        cancel_button: 'Cancel',
+        apply_button: 'Delete'
+    },
+    create_modal: {
+        title_header_create: 'Create Formula',
+        title_header_edit: 'Edit Formula',
+        title_header_table: 'Create Table Formula',
+        name: 'Formula Name',
+        placeholder_name: 'Type Formula Name',
+        invalid_name: 'cannot be used in the formula name.',
+        detail_title: 'Formulita',
+        detail_suggestion: 'Allows mathematical operations including',
+        detail_suggestion_operators: '+, -, *, /, ()',
+        syntax_success: 'Formula syntax is correct.',
+        syntax_error: 'Formula syntax error, please check your formula and retry.',
+        syntax_warning: 'Formula syntax correct, but some null values generate error',
+        test: 'Test',
+        clear: 'Clear',
+        insert_function: 'Insert Functions',
+        insert_column: 'Inset Columns',
+        search_function: 'Search',
+        search_column: 'Search',
+        box_function_empty: 'No Function Selected',
+        add_formula: 'Add to Formula',
+        cancel_button: 'Cancel',
+        apply_button: 'Save',
+        no_columns_available: 'No Columns Available',
+        create_toast: 'Formula Created Successfully.',
+        update_toast: 'Formula Updated Successfully',
+        required_name_toast: 'Formula Name is Required.',
+        parameters: 'Parameters',
+        example: 'Example'
+    },
+    functions_type: {
+        all: 'All',
+        numeric: 'Numeric',
+        string: 'String/Text',
+        date: 'Date/Time',
+        aggregate: 'Aggreagtes'
+    },
+    function_is_null: {
+        description: 'Replaces NULL with the specified replacement value.',
+        function_placeholder: 'isNull(column, replacement)',
+        param_column_name: 'column',
+        param_column_description: 'Column to check.',
+        param_replacement_name: 'replacement',
+        param_replacement_description: 'Replacement value.',
+    },
+    function_abs: {
+        description: 'Returns the absolute value of a value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned.',
+        function_placeholder: 'abs(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The argument whose absolute value is to be determined.',
+    },
+    function_acos: {
+        description: 'Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.',
+        function_placeholder: 'acos(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The value whose arc cosine is to be returned.',
+    },
+    function_asin: {
+        description: 'Returns the arc sine of a value; the returned angle is in the range -pi/2 through pi/2.',
+        function_placeholder: 'asin(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The value whose arc sine is to be returned.',
+    },
+    function_atan: {
+        description: 'Returns the arc tangent of a value; the returned angle is in the range -pi/2 through pi/2.',
+        function_placeholder: 'atan(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The value whose arc tangent is to be returned.',
+    },
+    function_atan_2: {
+        description: 'Returns the angle theta from the conversion of rectangular coordinates (x, y) to polar coordinates (r, theta). This method computes the phase theta by computing an arc tangent of y/x in the range of -pi to pi.',
+        function_placeholder: 'atan2(num1, num2)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The ordinate coordinate.',
+        param_num_2_name: 'num2',
+        param_num_2_description: 'The abscissa coordinate.',
+    },
+    function_cbrt: {
+        description: 'Returns the cube root of a value. For positive finite x, cbrt(-x) == -cbrt(x); that is, the cube root of a negative value is the negative of the cube root of that value\'s magnitude.',
+        function_placeholder: 'cbrt(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value.',
+    },
+    function_ceil: {
+        description: 'Returns the smallest (closest to negative infinity) value that is greater than or equal to the argument and is equal to a mathematical integer.',
+        function_placeholder: 'ceil(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value.',
+    },
+    function_copy_sign: {
+        description: 'Returns the first argument with the sign of the second argument. For this method, a NaN sign argument is always treated as if it were positive.',
+        function_placeholder: 'copySign(magnitude, sign)',
+        param_magnitude_name: 'magnitude',
+        param_magnitude_description: 'The parameter providing the magnitude of the result.',
+        param_sign_name: 'sign',
+        param_sign_description: 'The parameter providing the sign of the result.',
+    },
+    function_cos: {
+        description: 'Returns the trigonometric cosine of an angle.',
+        function_placeholder: 'cos(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'An angle, in radians.',
+    },
+    function_cosh: {
+        description: 'Returns the hyperbolic cosine of a value. The hyperbolic cosine of x is defined to be (ex + e-x)/2 where e is Euler\'s number.',
+        function_placeholder: 'cosh(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The number whose hyperbolic cosine is to be returned.',
+    },
+    function_exp: {
+        description: 'Returns Euler\'s number e raised to the power of a value.',
+        function_placeholder: 'exp(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The exponent to raise e to.',
+    },
+    function_expm_1: {
+        description: 'Returns e^x -1. Note that for values of x near 0, the exact sum of expm1(x) + 1 is much closer to the true result of e^x than exp(x).',
+        function_placeholder: 'expm1(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The exponent to raise e to in the computation of e^x -1.',
+    },
+    function_floor: {
+        description: 'Returns the largest (closest to positive infinity) value that is less than or equal to the argument and is equal to a mathematical integer.',
+        function_placeholder: 'floor(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value',
+    },
+    function_hypot: {
+        description: 'Returns sqrt(x^2 +y^2) without intermediate overflow or underflow.',
+        function_placeholder: 'hypot(num1, num2)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value',
+        param_num_2_name: 'num2',
+        param_num_2_description: 'Numeric value',
+    },
+    function_log: {
+        description: 'Returns the natural logarithm (base e) of a double value.',
+        function_placeholder: 'log(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value',
+    },
+    function_log_10: {
+        description: 'Returns the base 10 logarithm of a double value.',
+        function_placeholder: 'log10(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value',
+    },
+    function_log1p: {
+        description: 'Returns the natural logarithm of the sum of the argument and 1. Note that for small values x, the result of log1p(x) is much closer to the true result of ln(1 + x) than the floating-point evaluation of log(1.0+x).',
+        function_placeholder: 'log1p(x)',
+        param_x_name: 'x',
+        param_x_description: 'Numeric value',
+    },
+    function_max: {
+        description: 'Returns the greater of two double values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other negative zero, the result is positive zero.',
+        function_placeholder: 'max(num1, num2)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'An argument.',
+        param_num_2_name: 'num2',
+        param_num_2_description: 'Another argument.',
+    },
+    function_min: {
+        description: 'Returns the smaller of two double values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other is negative zero, the result is negative zero.',
+        function_placeholder: 'min(num1, num2)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'An argument.',
+        param_num_2_name: 'num2',
+        param_num_2_description: 'Another argument.',
+    },
+    function_next_after: {
+        description: 'Returns the floating-point number adjacent to the first argument in the direction of the second argument. If both arguments compare as equal the second argument is returned.',
+        function_placeholder: 'nextAfter(start, direction)',
+        param_start_name: 'start',
+        param_start_description: 'Starting floating-point value.',
+        param_direction_name: 'direction',
+        param_direction_description: 'Value indicating which of start\'s neighbors or start should be returned.',
+    },
+    function_next_down: {
+        description: 'Returns the floating-point value adjacent to the argument in the direction of negative infinity.',
+        function_placeholder: 'nextDown(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Starting floating-point value.',
+    },
+    function_next_up: {
+        description: 'Returns the floating-point value adjacent to the argument in the direction of positive infinity.',
+        function_placeholder: 'nextUp(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Starting floating-point value.',
+    },
+    function_pow: {
+        description: 'Returns the value of the first argument raised to the power of the second argument.',
+        function_placeholder: 'pow(num1, num2)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Base.',
+        param_num_2_name: 'num2',
+        param_num_2_description: 'The exponent.',
+    },
+    function_random: {
+        description: 'Returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0.',
+        function_placeholder: 'random()',
+    },
+    function_rint: {
+        description: 'Returns the double value that is closest in value to the argument and is equal to a mathematical integer. If two double values that are mathematical integers are equally close to the value of the argument, the result is the integer value that is even.',
+        function_placeholder: 'rint(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value.',
+    },
+    function_round: {
+        description: 'Returns the closest long to the argument, with ties rounding to positive infinity.',
+        function_placeholder: 'round(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'A floating-point value to be rounded to a long.',
+    },
+    function_scalb: {
+        description: 'Returns d × 2^scaleFactor rounded as if performed by a single correctly rounded floating-point multiply to a member of the double value set.',
+        function_placeholder: 'scalb(num1, scaleFactor)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Number to be scaled by a power of two.',
+        param_scale_factor_name: 'num1',
+        param_scale_factor_description: 'Power of 2 used to scale the first argument.',
+    },
+    function_signum: {
+        description: 'Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.',
+        function_placeholder: 'signum(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The floating-point value whose signum is to be returned.',
+    },
+    function_sin: {
+        description: 'Returns the trigonometric sine of an angle.',
+        function_placeholder: 'sin(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'An angle, in radians.',
+    },
+    function_sinh: {
+        description: 'Returns the hyperbolic sine of a double value. The hyperbolic sine of x is defined to be (e^x - e^(-x))/2 where e is Euler\'s number.',
+        function_placeholder: 'sinh(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The number whose hyperbolic sine is to be returned.',
+    },
+    function_sqrt: {
+        description: 'Returns the correctly rounded positive square root of a value.',
+        function_placeholder: 'sqrt(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'Numeric value.',
+    },
+    function_tan: {
+        description: 'Returns the trigonometric tangent of an angle.',
+        function_placeholder: 'tan(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'An angle, in radians.',
+    },
+    function_tanh: {
+        description: 'Returns the hyperbolic tangent of a double value. The hyperbolic tangent of x is defined to be (e^x - e^(-x))/(e^x + e^(-x)), in other words, sinh(x)/cosh(x). Note that the absolute value of the exact tanh is always less than 1.',
+        function_placeholder: 'tanh(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The number whose hyperbolic tangent is to be returned.',
+    },
+    function_to_degrees: {
+        description: 'Converts an angle measured in radians to an approximately equivalent angle measured in degrees. The conversion from radians to degrees is generally inexact; users should not expect cos(toRadians(90.0)) to exactly equal 0.0.',
+        function_placeholder: 'toDegrees(angrad)',
+        param_angrad_name: 'angrad',
+        param_angrad_description: 'An angle, in radians.',
+    },
+    function_to_radians: {
+        description: 'Converts an angle measured in degrees to an approximately equivalent angle measured in radians. The conversion from degrees to radians is generally inexact.',
+        function_placeholder: 'toRadians(angdeg)',
+        param_angdeg_name: 'angdeg',
+        param_angdeg_description: 'An angle, in degrees',
+    },
+    function_ulp: {
+        description: 'Returns the size of an ulp of the argument. An ulp, unit in the last place, of a value is the positive distance between this floating-point value and the double value next larger in magnitude. Note that for non-NaN x, ulp(-x) == ulp(x).',
+        function_placeholder: 'ulp(num1)',
+        param_num_1_name: 'num1',
+        param_num_1_description: 'The floating-point value whose ulp is to be returned.',
+    },
+    function_include: {
+        description: 'Returns true if and only if this string contains the specified sequence of char values.',
+        function_placeholder: 'String.include(CharSequence)',
+        param_char_sequence_name: 'CharSequence',
+        param_char_sequence_description: 'The sequence to search for.',
+    },
+    function_trim: {
+        description: 'Returns a string whose value is this string, with any leading and trailing whitespace removed.',
+        function_placeholder: 'String.trim()',
+    },
+    function_upper: {
+        description: 'Converts all of the characters in this String to upper case.',
+        function_placeholder: 'String.upper()',
+    },
+    function_lower: {
+        description: 'Converts all of the characters in this String to lower case.',
+        function_placeholder: 'String.lower()',
+    },
+    function_substring: {
+        description: 'Returns a string that is a substring of this string. The substring begins at the specified beginIndex and extends to the character at index endIndex - 1. Thus the length of the substring is endIndex-beginIndex.',
+        function_placeholder: 'String.substring(beginIndex, endIndex)',
+        param_begin_index_name: 'beginIndex',
+        param_begin_index_description: 'The beginning index, inclusive.',
+        param_end_index_name: 'endIndex',
+        param_end_index_description: 'The ending index, exclusive. (optional)',
+    },
+    function_replace: {
+        description: 'Replaces each substring of this string that matches the literal target sequence with the specified literal replacement sequence. The replacement proceeds from the beginning of the string to the end, for example, replacing "aa" with "b" in the string "aaa" will result in "ba" rather than "ab".',
+        function_placeholder: 'String.replace(target, replacement)',
+        param_target_name: 'target',
+        param_target_description: 'The sequence of char values to be replaced.',
+        param_replacement_name: 'replacement',
+        param_replacement_description: 'The replacement sequence of char values.',
+    },
+    function_length: {
+        description: 'Returns the length of the character sequence.',
+        function_placeholder: 'String.length()',
+    },
+    function_now: {
+        description: 'Return a date with the current time. Returned dates will have this format yyyy-MM-ddTHH:mm:ssZ.',
+        function_placeholder: 'now()',
+    },
+    function_date_parse: {
+        description: 'Return a Date from a String given a format.',
+        function_placeholder: 'dateParse(string_date, \'format\')',
+        param_string_date_name: 'string_date',
+        param_string_date_description: 'Date in string format.',
+        param_format_name: 'format',
+        param_format_description: 'Common suggested pattern letters you can use:<br>y = year (yy or ‘yyyy’)<br>M = month (MM)<br>d = day in month (dd)<br>h = hour (0-12) (hh)<br>H = hour (0-23) (HH)<br>m = minute in hour (mm)<br>s = seconds (ss)<br>S = milliseconds (SSS)<br>z = time zone text (e.g. Pacific Standard Time...)<br>Z = time zone, time offset (e.g. -0800).<br><br>Other formats may be validated as correct.',
+    },
+    function_date_format: {
+        description: 'Given a Date or a Column return a String with the Format given.',
+        function_placeholder: 'dateFormat(date_value, \'format\')',
+        param_date_value_name: 'date_value',
+        param_date_value_description: 'Date value.',
+        param_format_name: 'format',
+        param_format_description: 'Common suggested pattern letters you can use:<br>y = year (yy or ‘yyyy’)<br>M = month (MM)<br>d = day in month (dd)<br>h = hour (0-12) (hh)<br>H = hour (0-23) (HH)<br>m = minute in hour (mm)<br>s = seconds (ss)<br>S = milliseconds (SSS)<br>z = time zone text (e.g. Pacific Standard Time...)<br>Z = time zone, time offset (e.g. -0800).<br><br>Other formats may be validated as correct.',
+    },
+    function_date_add: {
+        description: 'Given a Date or a Column, add the specific value to the specific part.',
+        function_placeholder: 'dateAdd(date, date_part, interval_value)',
+        param_date_name: 'date',
+        param_date_description: 'This is the Date or Column to which you want to add.',
+        param_part_name: 'date_part',
+        param_part_description: 'This indicates the units of time that you want to add. For example if you want to add 2 days, then this will be DAYS. Date part allows: YEARS, MONTHS, DAYS, HOURS, MINUTES or SECONDS.',
+        param_value_name: 'interval_value',
+        param_value_description: 'This is the number of units of time that you want to add.',
+    },
+    function_date_subtract: {
+        description: 'Given a Date or a Column, subtract the specific value to the specific part.',
+        function_placeholder: 'dateSubtract(date, date_part, interval_value)',
+        param_date_name: 'date',
+        param_date_description: 'This is the Date or Column to which you want to subtract.',
+        param_part_name: 'date_part',
+        param_part_description: 'This indicates the units of time that you want to substract. For example if you want to substract 2 days, then this will be DAYS. Date part allows: YEARS, MONTHS, DAYS, HOURS, MINUTES or SECONDS.',
+        param_value_name: 'interval_value',
+        param_value_description: 'This is the number of units of time that you want to subtract.',
+    },
+    function_date_diff: {
+        description: 'Calculates the difference between two dates based on the date part requested.',
+        function_placeholder: 'dateDiff(date_value1, date_value2, date_part)',
+        param_date_value_one_name: 'date_value1',
+        param_date_value_one_description: 'The first date value.',
+        param_date_value_two_name: 'date_value2',
+        param_date_value_two_description: 'The second date value.',
+        param_date_part_requested_name: 'date_part',
+        param_date_part_requested_description: 'Date part allows: YEARS, MONTHS, DAYS, HOURS, MINUTES or SECONDS.',
+    },
+    function_date_is_null: {
+        description: 'Returns a string that replaces NULL with the specified replacement value.',
+        function_placeholder: 'dateIsNull(column, replacement)',
+        param_column_name: 'column',
+        param_column_description: 'Date column to check.',
+        param_replacement_name: 'replacement',
+        param_replacement_description: 'Date replacement value.<br>Common Replacement Value Formats:<br>○ Using another date column "dateIsNull(Column1, Column2)"<br>○ Using another date function "dateIsNull(Column, now())"<br>○ Using specified date "dateIsNull(Column, dateParse(\'dd/MM/yyyy\', \'dd/MM/yyyy\'))"',
+    },
+    function_agg_sum: {
+        description: 'A single-value metrics aggregation that sums up numeric values that are extracted from the documents',
+        function_placeholder: 'agg_sum(single_value)',
+        param_single_value_name: 'single_value',
+        param_single_value_description: 'Single-value',
+    },
+    function_agg_avg: {
+        description: 'A single-value metrics aggregation that computes the average of numeric values that are extracted from the documents',
+        function_placeholder: 'agg_avg(single_value)',
+        param_single_value_name: 'single_value',
+        param_single_value_description: 'Single-value',
+    },
+    function_agg_min: {
+        description: 'A single-value metrics aggregation that keeps track and returns the minimum value among numeric values extracted from the documents.',
+        function_placeholder: 'agg_min(single_value)',
+        param_single_value_name: 'single_value',
+        param_single_value_description: 'Single-value',
+    },
+    function_agg_max: {
+        description: 'A single-value metrics aggregation that keeps track and returns the maximum value among the numeric values extracted from the documents.',
+        function_placeholder: 'agg_max(single_value)',
+        param_single_value_name: 'single_value',
+        param_single_value_description: 'Single-value',
+    },
+    function_agg_distinctcount: {
+        description: 'A single-value metrics aggregation that calculates an approximate count of distinct values.',
+        function_placeholder: 'agg_distinctcount(single_value)',
+        param_single_value_name: 'single_value',
+        param_single_value_description: 'Single-value',
+    },
+    function_agg_count: {
+        description: 'A single-value metrics aggregation that counts the number of values that are extracted from the documents.',
+        function_placeholder: 'agg_count(single_value)',
+        param_single_value_name: 'single_value',
+        param_single_value_description: 'Single-value',
+    },
+};

package/src/globalization/labels/formula_builder/index.ts

@@ -0,0 +1 @@
+export * from './I18N_FORMULA_BUILDER';

package/src/globalization/labels/index.ts

@@ -0,0 +1,10 @@
+export * from './columns';
+export * from './common';
+export * from './dashboard';
+export * from './filters';
+export * from './panel';
+export * from './table_charts';
+export * from './I18N_DEFAULT';
+export * from './formula_builder';
+export * from './bucket_builder';
+export * from './chart_builder';

package/src/globalization/labels/panel/I18N_PANEL.ts

@@ -0,0 +1,108 @@
+import { II18nPanel } from "../../interfaces/panel";
+
+export const I18N_PANEL: II18nPanel = {
+    embed: {
+        embed_chart: 'Embed Chart',
+        embed_analyze_section: 'Embed Analyze Section',
+        learn_more: 'Learn more',
+        about_widget: 'about widget implementation.',
+        copy: 'Copy'
+    },
+    errors: {
+        missing_column: 'Missing Column.',
+        missing_bucket_column: 'Missing bucket column.',
+        missing_formula_column: 'Missing formula column.',
+        missing_linked_column: 'Missing linked column.',
+        no_data_found: 'No data found.',
+        server_error: 'Sever Error.',
+        try_again: 'Try Again',
+        chart_not_found: 'This {{panel}} is no longer available.',
+        service_unavailable: '{{panel}} not available at the moment.',
+        refresh_panel: 'Refresh panel',
+        restore_panel: 'Restore panel',
+        long_text: 'long-text',
+        drilldown_unavailable: 'No data found with drilldown.',
+        max_buckets_limit: 'The combination of data used in this chart exceeds the maximum number of data points that the system can return.<br><br>We recommend you try:<br>• Refining your data with <i>Max Data Points</i> or <i>Filters</i><br>• Using a <i>Date Grouping</i> that returns less data<br>• Using another chart visualization',
+        continuous_date_limit: 'The combination of data used in this chart exceeds the maximum number of data points that the system can return.<br><br>We recommend you try:<br>• Using a <i>Date Grouping</i> that returns less data<br>• Using another chart visualization<br>• Switching to Discrete Values',
+        continuous_numeric_limit: 'The combination of data used in this chart exceeds the maximum number of data points that the system can return.<br><br>We recommend you try:<br>• Using another chart visualization<br>• Switching to Discrete Values',
+        table_calculation_no_data_found: 'This <i>Table Calculation</i> resulted in NaN for all values.<br><br>We recommend you try:<br>• Another <i>Table Calculation</i><br>• Another <i>Aggregation</i>'
+    },
+    menu: {
+        edit: "Edit",
+        download: "Download",
+        duplicate: "Duplicate",
+        size: "Size",
+        delete: "Delete",
+        embed_chart: "Embed chart",
+        small: "Small",
+        medium: "Medium",
+        large: "Large",
+        jpg: 'JPG',
+        pdf: 'PDF',
+        csv: 'CSV',
+        csv_summary: 'CSV-Summary'
+    },
+    menu_options: {
+        see_data: 'See Data',
+        filter_by: 'Filter by',
+        drill_down_to: 'Drill-down to',
+        custom_drill: 'Drill Down to Next Level'
+    },
+    name: 'Panel',
+    records: 'Records',
+    refresh: "Refresh",
+    summary_display: {
+        display: 'Display',
+        value: 'Value',
+        both: 'Both',
+    },
+    summary_filter: {
+        positive: 'Positive',
+        negative: 'Negative',
+        both: 'Both'
+    },
+    summary_group: {
+        country: 'Country',
+        state: 'State',
+        city: 'City',
+        zip_code: 'Zip Code',
+        no_group: 'No Group'
+    },
+    summary_sorting: {
+        ascending: 'Ascending',
+        descending: 'Descending',
+        order_descending: '% Order Descending',
+        order_ascending: '% Order Ascending',
+        stop_order_descending: 'Stop Order Descending',
+        stop_order_ascending: 'Stop Order Ascending',
+        starts_order_descending: 'Stars Order Descending',
+        starts_order_ascending: 'Stars Order Ascending',
+        range_order_descending: 'Range Order Descending',
+        range_order_ascending: 'Range Order Ascending'
+    },
+    summary_views: {
+        bar_chart: 'Bar Chart',
+        metrics: 'Metrics',
+        list_view: 'List View',
+        fill_null: 'Fill / Null',
+        wordcloud: 'Wordcloud',
+        histogram: 'Histogram',
+        pie_chart: 'Pie Chart',
+        dot_map: 'Dot Map',
+        bubble_view: 'Bubble',
+        bubble_map: 'Bubble Map',
+        entities: 'Entities',
+        keyphrases: 'Keyphrases',
+        sentiment: 'Sentiment',
+        starts: 'Stars',
+        categories: 'Categories',
+        multiseries: 'Multiseries',
+        cluster_chart: 'Cluster Chart',
+    },
+    timeout_message: 'Calculating {{type}}. This process may take a while.',
+    tooltips: {
+        fit_panel: "Fit to panel",
+        no_filters: "No filters applied"
+    },
+    top: 'Top',
+};

package/src/globalization/labels/panel/index.ts

@@ -0,0 +1 @@
+export * from './I18N_PANEL';

package/src/globalization/labels/table_charts/I18N_TABLE_CHARTS.ts

@@ -0,0 +1,37 @@
+import { II18nTableCharts } from '../../interfaces/table_charts/II18nTableCharts';
+
+export const I18N_TABLE_CHARTS: II18nTableCharts = {
+    edit_label: "Edit Label",
+    inner_charts: {
+        tooltip: {
+            end: 'End',
+            max: 'Max',
+            min: 'Min',
+            start: 'Start'
+        }
+    },
+    pagination: {
+        records: 'Records',
+        records_per_page: 'Records per page',
+        total_records: 'Total records'
+    },
+    sort: {
+        asc: 'Asc',
+        desc: 'Desc',
+        multi_column_sort: "Apply Multi-Column Sort",
+        no_sorting: "No Sorting",
+        no_sorting_applied: "No Sorting Applied",
+        select_column: "Select column to sort by",
+        sorted_by: "Order by"
+    },
+    sort_tooltip: {
+        disabled_multi_sort_dropdown: 'Multi-Sorting disabled, add more columns to enable it.',
+        will_replace: "Selecting this column will replace the '{{column_name}}' sorting",
+    },
+    total: "total",
+    visualization: "Visualization",
+    visualization_items: {
+        values: "Values",
+        bars: "Bars"
+    }
+};

package/src/globalization/labels/table_charts/index.ts

@@ -0,0 +1 @@
+export * from './I18N_TABLE_CHARTS';

package/src/globalization/service/i18nextBuilder.ts

@@ -0,0 +1,52 @@
+import { IResourceI18n } from "../interfaces";
+import i18next from 'i18next';
+import { mergeDeep } from "../../general/object/mergeDeep";
+import { II18nServiceTranslateOption } from "../interfaces/II18nServiceTranslateOption";
+
+export class I18nServiceBuilder {
+
+  public static async buildI18n(i18nDefault: IResourceI18n, i18nResource: IResourceI18n): Promise<I18nService> {
+    return await this._initI18n(i18nDefault, i18nResource);
+  }
+
+  private static async _initI18n(i18nDefault: IResourceI18n, i18nResource: IResourceI18n): Promise<I18nService> {
+    
+    if (!i18next.isInitialized) {
+      await i18next
+        .init({
+          lng: 'en',
+          debug: false,
+          nsSeparator: false,
+          keySeparator: '.',
+          fallbackLng: false,
+          defaultNS: 'translation',
+          resources: {
+              en: {
+                  translation: this.setTranslations(i18nDefault, i18nResource),
+              }
+          }
+        });
+    }
+    return new I18nServiceConcrete(i18next);
+  }
+
+  public static  setTranslations(i18nDefault, i18nResource: IResourceI18n): IResourceI18n {
+    return mergeDeep(i18nResource, i18nDefault, { mergeExistingValues: false });
+  }
+}
+
+export abstract class I18nService {
+  abstract translate(key: string, options?: II18nServiceTranslateOption): string;
+}
+
+class I18nServiceConcrete extends I18nService {
+  _i18next: any;
+  constructor(i18nInstance: any) {
+    super();
+    this._i18next = i18nInstance;
+  }
+
+  translate(key: string, options?: II18nServiceTranslateOption) {
+    return this._i18next.t(`${key}`, options);
+  }
+}

package/src/globalization/service/index.ts

@@ -0,0 +1,2 @@
+export * from './i18nextBuilder';
+export * from './initI18n';

package/src/globalization/service/initI18n.ts

@@ -0,0 +1,6 @@
+import { IResourceI18n } from "../interfaces";
+import { I18nService, I18nServiceBuilder } from "../service/i18nextBuilder";
+
+export async function initI18n(i18nConfig: IResourceI18n = {}, i18nDefault: IResourceI18n = {}): Promise<I18nService> {
+    return await I18nServiceBuilder.buildI18n(i18nDefault, i18nConfig);
+}