| // Copyright 2007 The Closure Library Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS-IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| /** |
| * @fileoverview Utility functions for supporting Bidi issues. |
| */ |
| |
| |
| /** |
| * Namespace for bidi supporting functions. |
| */ |
| goog.provide('goog.i18n.bidi'); |
| goog.provide('goog.i18n.bidi.Dir'); |
| goog.provide('goog.i18n.bidi.DirectionalString'); |
| goog.provide('goog.i18n.bidi.Format'); |
| |
| |
| /** |
| * @define {boolean} FORCE_RTL forces the {@link goog.i18n.bidi.IS_RTL} constant |
| * to say that the current locale is a RTL locale. This should only be used |
| * if you want to override the default behavior for deciding whether the |
| * current locale is RTL or not. |
| * |
| * {@see goog.i18n.bidi.IS_RTL} |
| */ |
| goog.define('goog.i18n.bidi.FORCE_RTL', false); |
| |
| |
| /** |
| * Constant that defines whether or not the current locale is a RTL locale. |
| * If {@link goog.i18n.bidi.FORCE_RTL} is not true, this constant will default |
| * to check that {@link goog.LOCALE} is one of a few major RTL locales. |
| * |
| * <p>This is designed to be a maximally efficient compile-time constant. For |
| * example, for the default goog.LOCALE, compiling |
| * "if (goog.i18n.bidi.IS_RTL) alert('rtl') else {}" should produce no code. It |
| * is this design consideration that limits the implementation to only |
| * supporting a few major RTL locales, as opposed to the broader repertoire of |
| * something like goog.i18n.bidi.isRtlLanguage. |
| * |
| * <p>Since this constant refers to the directionality of the locale, it is up |
| * to the caller to determine if this constant should also be used for the |
| * direction of the UI. |
| * |
| * {@see goog.LOCALE} |
| * |
| * @type {boolean} |
| * |
| * TODO(user): write a test that checks that this is a compile-time constant. |
| */ |
| goog.i18n.bidi.IS_RTL = goog.i18n.bidi.FORCE_RTL || |
| ((goog.LOCALE.substring(0, 2).toLowerCase() == 'ar' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'fa' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'he' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'iw' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'ps' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'sd' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'ug' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'ur' || |
| goog.LOCALE.substring(0, 2).toLowerCase() == 'yi') && |
| (goog.LOCALE.length == 2 || goog.LOCALE.substring(2, 3) == '-' || |
| goog.LOCALE.substring(2, 3) == '_')) || |
| (goog.LOCALE.length >= 3 && |
| goog.LOCALE.substring(0, 3).toLowerCase() == 'ckb' && |
| (goog.LOCALE.length == 3 || goog.LOCALE.substring(3, 4) == '-' || |
| goog.LOCALE.substring(3, 4) == '_')); |
| |
| |
| /** |
| * Unicode formatting characters and directionality string constants. |
| * @enum {string} |
| */ |
| goog.i18n.bidi.Format = { |
| /** Unicode "Left-To-Right Embedding" (LRE) character. */ |
| LRE: '\u202A', |
| /** Unicode "Right-To-Left Embedding" (RLE) character. */ |
| RLE: '\u202B', |
| /** Unicode "Pop Directional Formatting" (PDF) character. */ |
| PDF: '\u202C', |
| /** Unicode "Left-To-Right Mark" (LRM) character. */ |
| LRM: '\u200E', |
| /** Unicode "Right-To-Left Mark" (RLM) character. */ |
| RLM: '\u200F' |
| }; |
| |
| |
| /** |
| * Directionality enum. |
| * @enum {number} |
| */ |
| goog.i18n.bidi.Dir = { |
| /** |
| * Left-to-right. |
| */ |
| LTR: 1, |
| |
| /** |
| * Right-to-left. |
| */ |
| RTL: -1, |
| |
| /** |
| * Neither left-to-right nor right-to-left. |
| */ |
| NEUTRAL: 0 |
| }; |
| |
| |
| /** |
| * 'right' string constant. |
| * @type {string} |
| */ |
| goog.i18n.bidi.RIGHT = 'right'; |
| |
| |
| /** |
| * 'left' string constant. |
| * @type {string} |
| */ |
| goog.i18n.bidi.LEFT = 'left'; |
| |
| |
| /** |
| * 'left' if locale is RTL, 'right' if not. |
| * @type {string} |
| */ |
| goog.i18n.bidi.I18N_RIGHT = |
| goog.i18n.bidi.IS_RTL ? goog.i18n.bidi.LEFT : goog.i18n.bidi.RIGHT; |
| |
| |
| /** |
| * 'right' if locale is RTL, 'left' if not. |
| * @type {string} |
| */ |
| goog.i18n.bidi.I18N_LEFT = |
| goog.i18n.bidi.IS_RTL ? goog.i18n.bidi.RIGHT : goog.i18n.bidi.LEFT; |
| |
| |
| /** |
| * Convert a directionality given in various formats to a goog.i18n.bidi.Dir |
| * constant. Useful for interaction with different standards of directionality |
| * representation. |
| * |
| * @param {goog.i18n.bidi.Dir|number|boolean|null} givenDir Directionality given |
| * in one of the following formats: |
| * 1. A goog.i18n.bidi.Dir constant. |
| * 2. A number (positive = LTR, negative = RTL, 0 = neutral). |
| * 3. A boolean (true = RTL, false = LTR). |
| * 4. A null for unknown directionality. |
| * @param {boolean=} opt_noNeutral Whether a givenDir of zero or |
| * goog.i18n.bidi.Dir.NEUTRAL should be treated as null, i.e. unknown, in |
| * order to preserve legacy behavior. |
| * @return {?goog.i18n.bidi.Dir} A goog.i18n.bidi.Dir constant matching the |
| * given directionality. If given null, returns null (i.e. unknown). |
| */ |
| goog.i18n.bidi.toDir = function(givenDir, opt_noNeutral) { |
| if (typeof givenDir == 'number') { |
| // This includes the non-null goog.i18n.bidi.Dir case. |
| return givenDir > 0 ? goog.i18n.bidi.Dir.LTR : givenDir < 0 ? |
| goog.i18n.bidi.Dir.RTL : |
| opt_noNeutral ? null : goog.i18n.bidi.Dir.NEUTRAL; |
| } else if (givenDir == null) { |
| return null; |
| } else { |
| // Must be typeof givenDir == 'boolean'. |
| return givenDir ? goog.i18n.bidi.Dir.RTL : goog.i18n.bidi.Dir.LTR; |
| } |
| }; |
| |
| |
| /** |
| * A practical pattern to identify strong LTR characters. This pattern is not |
| * theoretically correct according to the Unicode standard. It is simplified for |
| * performance and small code size. |
| * @type {string} |
| * @private |
| */ |
| goog.i18n.bidi.ltrChars_ = |
| 'A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02B8\u0300-\u0590\u0800-\u1FFF' + |
| '\u200E\u2C00-\uFB1C\uFE00-\uFE6F\uFEFD-\uFFFF'; |
| |
| |
| /** |
| * A practical pattern to identify strong RTL character. This pattern is not |
| * theoretically correct according to the Unicode standard. It is simplified |
| * for performance and small code size. |
| * @type {string} |
| * @private |
| */ |
| goog.i18n.bidi.rtlChars_ = |
| '\u0591-\u06EF\u06FA-\u07FF\u200F\uFB1D-\uFDFF\uFE70-\uFEFC'; |
| |
| |
| /** |
| * Simplified regular expression for an HTML tag (opening or closing) or an HTML |
| * escape. We might want to skip over such expressions when estimating the text |
| * directionality. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.htmlSkipReg_ = /<[^>]*>|&[^;]+;/g; |
| |
| |
| /** |
| * Returns the input text with spaces instead of HTML tags or HTML escapes, if |
| * opt_isStripNeeded is true. Else returns the input as is. |
| * Useful for text directionality estimation. |
| * Note: the function should not be used in other contexts; it is not 100% |
| * correct, but rather a good-enough implementation for directionality |
| * estimation purposes. |
| * @param {string} str The given string. |
| * @param {boolean=} opt_isStripNeeded Whether to perform the stripping. |
| * Default: false (to retain consistency with calling functions). |
| * @return {string} The given string cleaned of HTML tags / escapes. |
| * @private |
| */ |
| goog.i18n.bidi.stripHtmlIfNeeded_ = function(str, opt_isStripNeeded) { |
| return opt_isStripNeeded ? str.replace(goog.i18n.bidi.htmlSkipReg_, '') : str; |
| }; |
| |
| |
| /** |
| * Regular expression to check for RTL characters. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.rtlCharReg_ = new RegExp('[' + goog.i18n.bidi.rtlChars_ + ']'); |
| |
| |
| /** |
| * Regular expression to check for LTR characters. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.ltrCharReg_ = new RegExp('[' + goog.i18n.bidi.ltrChars_ + ']'); |
| |
| |
| /** |
| * Test whether the given string has any RTL characters in it. |
| * @param {string} str The given string that need to be tested. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether the string contains RTL characters. |
| */ |
| goog.i18n.bidi.hasAnyRtl = function(str, opt_isHtml) { |
| return goog.i18n.bidi.rtlCharReg_.test( |
| goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml)); |
| }; |
| |
| |
| /** |
| * Test whether the given string has any RTL characters in it. |
| * @param {string} str The given string that need to be tested. |
| * @return {boolean} Whether the string contains RTL characters. |
| * @deprecated Use hasAnyRtl. |
| */ |
| goog.i18n.bidi.hasRtlChar = goog.i18n.bidi.hasAnyRtl; |
| |
| |
| /** |
| * Test whether the given string has any LTR characters in it. |
| * @param {string} str The given string that need to be tested. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether the string contains LTR characters. |
| */ |
| goog.i18n.bidi.hasAnyLtr = function(str, opt_isHtml) { |
| return goog.i18n.bidi.ltrCharReg_.test( |
| goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml)); |
| }; |
| |
| |
| /** |
| * Regular expression pattern to check if the first character in the string |
| * is LTR. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.ltrRe_ = new RegExp('^[' + goog.i18n.bidi.ltrChars_ + ']'); |
| |
| |
| /** |
| * Regular expression pattern to check if the first character in the string |
| * is RTL. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.rtlRe_ = new RegExp('^[' + goog.i18n.bidi.rtlChars_ + ']'); |
| |
| |
| /** |
| * Check if the first character in the string is RTL or not. |
| * @param {string} str The given string that need to be tested. |
| * @return {boolean} Whether the first character in str is an RTL char. |
| */ |
| goog.i18n.bidi.isRtlChar = function(str) { |
| return goog.i18n.bidi.rtlRe_.test(str); |
| }; |
| |
| |
| /** |
| * Check if the first character in the string is LTR or not. |
| * @param {string} str The given string that need to be tested. |
| * @return {boolean} Whether the first character in str is an LTR char. |
| */ |
| goog.i18n.bidi.isLtrChar = function(str) { |
| return goog.i18n.bidi.ltrRe_.test(str); |
| }; |
| |
| |
| /** |
| * Check if the first character in the string is neutral or not. |
| * @param {string} str The given string that need to be tested. |
| * @return {boolean} Whether the first character in str is a neutral char. |
| */ |
| goog.i18n.bidi.isNeutralChar = function(str) { |
| return !goog.i18n.bidi.isLtrChar(str) && !goog.i18n.bidi.isRtlChar(str); |
| }; |
| |
| |
| /** |
| * Regular expressions to check if a piece of text is of LTR directionality |
| * on first character with strong directionality. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.ltrDirCheckRe_ = new RegExp( |
| '^[^' + goog.i18n.bidi.rtlChars_ + ']*[' + goog.i18n.bidi.ltrChars_ + ']'); |
| |
| |
| /** |
| * Regular expressions to check if a piece of text is of RTL directionality |
| * on first character with strong directionality. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.rtlDirCheckRe_ = new RegExp( |
| '^[^' + goog.i18n.bidi.ltrChars_ + ']*[' + goog.i18n.bidi.rtlChars_ + ']'); |
| |
| |
| /** |
| * Check whether the first strongly directional character (if any) is RTL. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether RTL directionality is detected using the first |
| * strongly-directional character method. |
| */ |
| goog.i18n.bidi.startsWithRtl = function(str, opt_isHtml) { |
| return goog.i18n.bidi.rtlDirCheckRe_.test( |
| goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml)); |
| }; |
| |
| |
| /** |
| * Check whether the first strongly directional character (if any) is RTL. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether RTL directionality is detected using the first |
| * strongly-directional character method. |
| * @deprecated Use startsWithRtl. |
| */ |
| goog.i18n.bidi.isRtlText = goog.i18n.bidi.startsWithRtl; |
| |
| |
| /** |
| * Check whether the first strongly directional character (if any) is LTR. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether LTR directionality is detected using the first |
| * strongly-directional character method. |
| */ |
| goog.i18n.bidi.startsWithLtr = function(str, opt_isHtml) { |
| return goog.i18n.bidi.ltrDirCheckRe_.test( |
| goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml)); |
| }; |
| |
| |
| /** |
| * Check whether the first strongly directional character (if any) is LTR. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether LTR directionality is detected using the first |
| * strongly-directional character method. |
| * @deprecated Use startsWithLtr. |
| */ |
| goog.i18n.bidi.isLtrText = goog.i18n.bidi.startsWithLtr; |
| |
| |
| /** |
| * Regular expression to check if a string looks like something that must |
| * always be LTR even in RTL text, e.g. a URL. When estimating the |
| * directionality of text containing these, we treat these as weakly LTR, |
| * like numbers. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.isRequiredLtrRe_ = /^http:\/\/.*/; |
| |
| |
| /** |
| * Check whether the input string either contains no strongly directional |
| * characters or looks like a url. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether neutral directionality is detected. |
| */ |
| goog.i18n.bidi.isNeutralText = function(str, opt_isHtml) { |
| str = goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml); |
| return goog.i18n.bidi.isRequiredLtrRe_.test(str) || |
| !goog.i18n.bidi.hasAnyLtr(str) && !goog.i18n.bidi.hasAnyRtl(str); |
| }; |
| |
| |
| /** |
| * Regular expressions to check if the last strongly-directional character in a |
| * piece of text is LTR. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.ltrExitDirCheckRe_ = new RegExp( |
| '[' + goog.i18n.bidi.ltrChars_ + '][^' + goog.i18n.bidi.rtlChars_ + ']*$'); |
| |
| |
| /** |
| * Regular expressions to check if the last strongly-directional character in a |
| * piece of text is RTL. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.rtlExitDirCheckRe_ = new RegExp( |
| '[' + goog.i18n.bidi.rtlChars_ + '][^' + goog.i18n.bidi.ltrChars_ + ']*$'); |
| |
| |
| /** |
| * Check if the exit directionality a piece of text is LTR, i.e. if the last |
| * strongly-directional character in the string is LTR. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether LTR exit directionality was detected. |
| */ |
| goog.i18n.bidi.endsWithLtr = function(str, opt_isHtml) { |
| return goog.i18n.bidi.ltrExitDirCheckRe_.test( |
| goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml)); |
| }; |
| |
| |
| /** |
| * Check if the exit directionality a piece of text is LTR, i.e. if the last |
| * strongly-directional character in the string is LTR. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether LTR exit directionality was detected. |
| * @deprecated Use endsWithLtr. |
| */ |
| goog.i18n.bidi.isLtrExitText = goog.i18n.bidi.endsWithLtr; |
| |
| |
| /** |
| * Check if the exit directionality a piece of text is RTL, i.e. if the last |
| * strongly-directional character in the string is RTL. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether RTL exit directionality was detected. |
| */ |
| goog.i18n.bidi.endsWithRtl = function(str, opt_isHtml) { |
| return goog.i18n.bidi.rtlExitDirCheckRe_.test( |
| goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml)); |
| }; |
| |
| |
| /** |
| * Check if the exit directionality a piece of text is RTL, i.e. if the last |
| * strongly-directional character in the string is RTL. |
| * @param {string} str String being checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether RTL exit directionality was detected. |
| * @deprecated Use endsWithRtl. |
| */ |
| goog.i18n.bidi.isRtlExitText = goog.i18n.bidi.endsWithRtl; |
| |
| |
| /** |
| * A regular expression for matching right-to-left language codes. |
| * See {@link #isRtlLanguage} for the design. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.rtlLocalesRe_ = new RegExp( |
| '^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|' + |
| '.*[-_](Arab|Hebr|Thaa|Nkoo|Tfng))' + |
| '(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)', |
| 'i'); |
| |
| |
| /** |
| * Check if a BCP 47 / III language code indicates an RTL language, i.e. either: |
| * - a language code explicitly specifying one of the right-to-left scripts, |
| * e.g. "az-Arab", or<p> |
| * - a language code specifying one of the languages normally written in a |
| * right-to-left script, e.g. "fa" (Farsi), except ones explicitly specifying |
| * Latin or Cyrillic script (which are the usual LTR alternatives).<p> |
| * The list of right-to-left scripts appears in the 100-199 range in |
| * http://www.unicode.org/iso15924/iso15924-num.html, of which Arabic and |
| * Hebrew are by far the most widely used. We also recognize Thaana, N'Ko, and |
| * Tifinagh, which also have significant modern usage. The rest (Syriac, |
| * Samaritan, Mandaic, etc.) seem to have extremely limited or no modern usage |
| * and are not recognized to save on code size. |
| * The languages usually written in a right-to-left script are taken as those |
| * with Suppress-Script: Hebr|Arab|Thaa|Nkoo|Tfng in |
| * http://www.iana.org/assignments/language-subtag-registry, |
| * as well as Central (or Sorani) Kurdish (ckb), Sindhi (sd) and Uyghur (ug). |
| * Other subtags of the language code, e.g. regions like EG (Egypt), are |
| * ignored. |
| * @param {string} lang BCP 47 (a.k.a III) language code. |
| * @return {boolean} Whether the language code is an RTL language. |
| */ |
| goog.i18n.bidi.isRtlLanguage = function(lang) { |
| return goog.i18n.bidi.rtlLocalesRe_.test(lang); |
| }; |
| |
| |
| /** |
| * Regular expression for bracket guard replacement in text. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.bracketGuardTextRe_ = |
| /(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(<.*?>+)/g; |
| |
| |
| /** |
| * Apply bracket guard using LRM and RLM. This is to address the problem of |
| * messy bracket display frequently happens in RTL layout. |
| * This function works for plain text, not for HTML. In HTML, the opening |
| * bracket might be in a different context than the closing bracket (such as |
| * an attribute value). |
| * @param {string} s The string that need to be processed. |
| * @param {boolean=} opt_isRtlContext specifies default direction (usually |
| * direction of the UI). |
| * @return {string} The processed string, with all bracket guarded. |
| */ |
| goog.i18n.bidi.guardBracketInText = function(s, opt_isRtlContext) { |
| var useRtl = opt_isRtlContext === undefined ? goog.i18n.bidi.hasAnyRtl(s) : |
| opt_isRtlContext; |
| var mark = useRtl ? goog.i18n.bidi.Format.RLM : goog.i18n.bidi.Format.LRM; |
| return s.replace(goog.i18n.bidi.bracketGuardTextRe_, mark + '$&' + mark); |
| }; |
| |
| |
| /** |
| * Enforce the html snippet in RTL directionality regardless overall context. |
| * If the html piece was enclosed by tag, dir will be applied to existing |
| * tag, otherwise a span tag will be added as wrapper. For this reason, if |
| * html snippet start with with tag, this tag must enclose the whole piece. If |
| * the tag already has a dir specified, this new one will override existing |
| * one in behavior (tested on FF and IE). |
| * @param {string} html The string that need to be processed. |
| * @return {string} The processed string, with directionality enforced to RTL. |
| */ |
| goog.i18n.bidi.enforceRtlInHtml = function(html) { |
| if (html.charAt(0) == '<') { |
| return html.replace(/<\w+/, '$& dir=rtl'); |
| } |
| // '\n' is important for FF so that it won't incorrectly merge span groups |
| return '\n<span dir=rtl>' + html + '</span>'; |
| }; |
| |
| |
| /** |
| * Enforce RTL on both end of the given text piece using unicode BiDi formatting |
| * characters RLE and PDF. |
| * @param {string} text The piece of text that need to be wrapped. |
| * @return {string} The wrapped string after process. |
| */ |
| goog.i18n.bidi.enforceRtlInText = function(text) { |
| return goog.i18n.bidi.Format.RLE + text + goog.i18n.bidi.Format.PDF; |
| }; |
| |
| |
| /** |
| * Enforce the html snippet in RTL directionality regardless overall context. |
| * If the html piece was enclosed by tag, dir will be applied to existing |
| * tag, otherwise a span tag will be added as wrapper. For this reason, if |
| * html snippet start with with tag, this tag must enclose the whole piece. If |
| * the tag already has a dir specified, this new one will override existing |
| * one in behavior (tested on FF and IE). |
| * @param {string} html The string that need to be processed. |
| * @return {string} The processed string, with directionality enforced to RTL. |
| */ |
| goog.i18n.bidi.enforceLtrInHtml = function(html) { |
| if (html.charAt(0) == '<') { |
| return html.replace(/<\w+/, '$& dir=ltr'); |
| } |
| // '\n' is important for FF so that it won't incorrectly merge span groups |
| return '\n<span dir=ltr>' + html + '</span>'; |
| }; |
| |
| |
| /** |
| * Enforce LTR on both end of the given text piece using unicode BiDi formatting |
| * characters LRE and PDF. |
| * @param {string} text The piece of text that need to be wrapped. |
| * @return {string} The wrapped string after process. |
| */ |
| goog.i18n.bidi.enforceLtrInText = function(text) { |
| return goog.i18n.bidi.Format.LRE + text + goog.i18n.bidi.Format.PDF; |
| }; |
| |
| |
| /** |
| * Regular expression to find dimensions such as "padding: .3 0.4ex 5px 6;" |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.dimensionsRe_ = |
| /:\s*([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)/g; |
| |
| |
| /** |
| * Regular expression for left. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.leftRe_ = /left/gi; |
| |
| |
| /** |
| * Regular expression for right. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.rightRe_ = /right/gi; |
| |
| |
| /** |
| * Placeholder regular expression for swapping. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.tempRe_ = /%%%%/g; |
| |
| |
| /** |
| * Swap location parameters and 'left'/'right' in CSS specification. The |
| * processed string will be suited for RTL layout. Though this function can |
| * cover most cases, there are always exceptions. It is suggested to put |
| * those exceptions in separate group of CSS string. |
| * @param {string} cssStr CSS spefication string. |
| * @return {string} Processed CSS specification string. |
| */ |
| goog.i18n.bidi.mirrorCSS = function(cssStr) { |
| return cssStr |
| . |
| // reverse dimensions |
| replace(goog.i18n.bidi.dimensionsRe_, ':$1 $4 $3 $2') |
| .replace(goog.i18n.bidi.leftRe_, '%%%%') |
| . // swap left and right |
| replace(goog.i18n.bidi.rightRe_, goog.i18n.bidi.LEFT) |
| .replace(goog.i18n.bidi.tempRe_, goog.i18n.bidi.RIGHT); |
| }; |
| |
| |
| /** |
| * Regular expression for hebrew double quote substitution, finding quote |
| * directly after hebrew characters. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.doubleQuoteSubstituteRe_ = /([\u0591-\u05f2])"/g; |
| |
| |
| /** |
| * Regular expression for hebrew single quote substitution, finding quote |
| * directly after hebrew characters. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.singleQuoteSubstituteRe_ = /([\u0591-\u05f2])'/g; |
| |
| |
| /** |
| * Replace the double and single quote directly after a Hebrew character with |
| * GERESH and GERSHAYIM. In such case, most likely that's user intention. |
| * @param {string} str String that need to be processed. |
| * @return {string} Processed string with double/single quote replaced. |
| */ |
| goog.i18n.bidi.normalizeHebrewQuote = function(str) { |
| return str.replace(goog.i18n.bidi.doubleQuoteSubstituteRe_, '$1\u05f4') |
| .replace(goog.i18n.bidi.singleQuoteSubstituteRe_, '$1\u05f3'); |
| }; |
| |
| |
| /** |
| * Regular expression to split a string into "words" for directionality |
| * estimation based on relative word counts. |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.wordSeparatorRe_ = /\s+/; |
| |
| |
| /** |
| * Regular expression to check if a string contains any numerals. Used to |
| * differentiate between completely neutral strings and those containing |
| * numbers, which are weakly LTR. |
| * |
| * Native Arabic digits (\u0660 - \u0669) are not included because although they |
| * do flow left-to-right inside a number, this is the case even if the overall |
| * directionality is RTL, and a mathematical expression using these digits is |
| * supposed to flow right-to-left overall, including unary plus and minus |
| * appearing to the right of a number, and this does depend on the overall |
| * directionality being RTL. The digits used in Farsi (\u06F0 - \u06F9), on the |
| * other hand, are included, since Farsi math (including unary plus and minus) |
| * does flow left-to-right. |
| * |
| * @type {RegExp} |
| * @private |
| */ |
| goog.i18n.bidi.hasNumeralsRe_ = /[\d\u06f0-\u06f9]/; |
| |
| |
| /** |
| * This constant controls threshold of RTL directionality. |
| * @type {number} |
| * @private |
| */ |
| goog.i18n.bidi.rtlDetectionThreshold_ = 0.40; |
| |
| |
| /** |
| * Estimates the directionality of a string based on relative word counts. |
| * If the number of RTL words is above a certain percentage of the total number |
| * of strongly directional words, returns RTL. |
| * Otherwise, if any words are strongly or weakly LTR, returns LTR. |
| * Otherwise, returns UNKNOWN, which is used to mean "neutral". |
| * Numbers are counted as weakly LTR. |
| * @param {string} str The string to be checked. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {goog.i18n.bidi.Dir} Estimated overall directionality of {@code str}. |
| */ |
| goog.i18n.bidi.estimateDirection = function(str, opt_isHtml) { |
| var rtlCount = 0; |
| var totalCount = 0; |
| var hasWeaklyLtr = false; |
| var tokens = goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml) |
| .split(goog.i18n.bidi.wordSeparatorRe_); |
| for (var i = 0; i < tokens.length; i++) { |
| var token = tokens[i]; |
| if (goog.i18n.bidi.startsWithRtl(token)) { |
| rtlCount++; |
| totalCount++; |
| } else if (goog.i18n.bidi.isRequiredLtrRe_.test(token)) { |
| hasWeaklyLtr = true; |
| } else if (goog.i18n.bidi.hasAnyLtr(token)) { |
| totalCount++; |
| } else if (goog.i18n.bidi.hasNumeralsRe_.test(token)) { |
| hasWeaklyLtr = true; |
| } |
| } |
| |
| return totalCount == 0 ? |
| (hasWeaklyLtr ? goog.i18n.bidi.Dir.LTR : goog.i18n.bidi.Dir.NEUTRAL) : |
| (rtlCount / totalCount > goog.i18n.bidi.rtlDetectionThreshold_ ? |
| goog.i18n.bidi.Dir.RTL : |
| goog.i18n.bidi.Dir.LTR); |
| }; |
| |
| |
| /** |
| * Check the directionality of a piece of text, return true if the piece of |
| * text should be laid out in RTL direction. |
| * @param {string} str The piece of text that need to be detected. |
| * @param {boolean=} opt_isHtml Whether str is HTML / HTML-escaped. |
| * Default: false. |
| * @return {boolean} Whether this piece of text should be laid out in RTL. |
| */ |
| goog.i18n.bidi.detectRtlDirectionality = function(str, opt_isHtml) { |
| return goog.i18n.bidi.estimateDirection(str, opt_isHtml) == |
| goog.i18n.bidi.Dir.RTL; |
| }; |
| |
| |
| /** |
| * Sets text input element's directionality and text alignment based on a |
| * given directionality. Does nothing if the given directionality is unknown or |
| * neutral. |
| * @param {Element} element Input field element to set directionality to. |
| * @param {goog.i18n.bidi.Dir|number|boolean|null} dir Desired directionality, |
| * given in one of the following formats: |
| * 1. A goog.i18n.bidi.Dir constant. |
| * 2. A number (positive = LRT, negative = RTL, 0 = neutral). |
| * 3. A boolean (true = RTL, false = LTR). |
| * 4. A null for unknown directionality. |
| */ |
| goog.i18n.bidi.setElementDirAndAlign = function(element, dir) { |
| if (element) { |
| dir = goog.i18n.bidi.toDir(dir); |
| if (dir) { |
| element.style.textAlign = dir == goog.i18n.bidi.Dir.RTL ? |
| goog.i18n.bidi.RIGHT : |
| goog.i18n.bidi.LEFT; |
| element.dir = dir == goog.i18n.bidi.Dir.RTL ? 'rtl' : 'ltr'; |
| } |
| } |
| }; |
| |
| |
| /** |
| * Sets element dir based on estimated directionality of the given text. |
| * @param {!Element} element |
| * @param {string} text |
| */ |
| goog.i18n.bidi.setElementDirByTextDirectionality = function(element, text) { |
| switch (goog.i18n.bidi.estimateDirection(text)) { |
| case (goog.i18n.bidi.Dir.LTR): |
| element.dir = 'ltr'; |
| break; |
| case (goog.i18n.bidi.Dir.RTL): |
| element.dir = 'rtl'; |
| break; |
| default: |
| // Default for no direction, inherit from document. |
| element.removeAttribute('dir'); |
| } |
| }; |
| |
| |
| |
| /** |
| * Strings that have an (optional) known direction. |
| * |
| * Implementations of this interface are string-like objects that carry an |
| * attached direction, if known. |
| * @interface |
| */ |
| goog.i18n.bidi.DirectionalString = function() {}; |
| |
| |
| /** |
| * Interface marker of the DirectionalString interface. |
| * |
| * This property can be used to determine at runtime whether or not an object |
| * implements this interface. All implementations of this interface set this |
| * property to {@code true}. |
| * @type {boolean} |
| */ |
| goog.i18n.bidi.DirectionalString.prototype |
| .implementsGoogI18nBidiDirectionalString; |
| |
| |
| /** |
| * Retrieves this object's known direction (if any). |
| * @return {?goog.i18n.bidi.Dir} The known direction. Null if unknown. |
| */ |
| goog.i18n.bidi.DirectionalString.prototype.getDirection; |