scriptshifter/legacy/processNumbers.ts

private processNumbers(pinyinString: string, tag: string, code: string): string {
    let outputString = "";
    let useNumVersion = false;
    //useNumVersion is set in specific subfields where we definitely want to treat numbers as numbers
    if ((tag == "245" || tag == "830") && code == "n") {
       useNumVersion = true;
    }

    /*
     * The input string is split, with any space or punctuation character (except for #) as the delimiter.
     * The delimiters will be captured and included in the string of tokens.  Only the even-numbered
     * array elements are the true 'tokens', so the code for processing tokens is run only for even
     * values of j.
     */
    let tokens: string[] = pinyinString.split(new RegExp("([^\\P{P}#]|\\s)","u"));
    let numTokenPattern = "^([A-Za-z]+)#([0-9]*)$";
    let numToken_re = new RegExp(numTokenPattern);
    let n = tokens.length
    //this.alert.info(tokens.join("|"),{autoClose: false})
    for (let i = 0; i < n; i++) {
        let toki = tokens[i];
        if (toki.match(numToken_re)) {
            /*
             * When a numerical token (containing #) is reached, the inner loop consumes it and all consecutive numerical tokens
             * found after it.  Two versions of the string are maintained.  The textVersion is the original pinyin (minus the
             * # suffixes).  In the numVersion, characters representing numbers are converted to Arabic numerals.  When a
             * non-numerical token (or end of string) is encountered, the string of numerical tokens is evaluated to determine
             * which version should be used in the output string.  The outer loop then continues where the inner loop left off.
             */
            let textVersion = "";
            let numVersion = "";
            for (let j = i; j < n; j++) {
                let tokj = tokens[j];
                /* a token without # (or the end of string) is reached */
                if ((j % 2 == 0 && !tokj.match(numToken_re)) || j == n - 1) {
                    //If this runs, then we are on the last token and it is numeric. Add text after # (if present) to numerical version
                    let m = tokj.match(numToken_re);
                    if (m) {
                        textVersion += m[1]
                        if (m[2] == "") {
                            numVersion += m[1];
                        } else {
                            numVersion += m[2];
                        }
                    } else if (j == n - 1) {
                    //if last token is non-numerical, just tack it on.
                        textVersion += tokj;
                        numVersion += tokj;
                    } else if (textVersion.length > 0 && numVersion.length > 0) {
                    //if not at end of string yet and token is non-numerical, remove the last delimiter that was appended
                    //(outer loop will pick up at this point)
                        textVersion = textVersion.substring(0, textVersion.length - 1);
                        numVersion = numVersion.substring(0, numVersion.length - 1);
                    }
                    //evaluate numerical string that has been constructed so far
                    //use num version for ordinals and date strings
                    if (numVersion.match(/^di [0-9]/i) ||
                        numVersion.match(/[0-9] [0-9] [0-9] [0-9]/) ||
                        numVersion.match(/[0-9]+ nian [0-9]+ yue/i) ||
                        numVersion.match(/"[0-9]+ yue [0-9]+ ri/i) ||
                        useNumVersion
                       ) {
                        useNumVersion = true;
                        /*
                         * At this point, string may contain literal translations of Chinese numerals
                         * Convert these to Arabic numerals (for example "2 10 7" = "27").
                         */

                        while (numVersion.match(/[0-9] 10+/) || numVersion.match(/[1-9]0+ [1-9]/)) {
                            m = numVersion.match(/([0-9]+) ([1-9]0+)/);
                            if (m) {
                                let sum = Number(m[1]) * Number(m[2]);
                                numVersion = numVersion.replace(/[0-9]+ [1-9]0+/, String(sum));
                            } else {
                                let mb = numVersion.match(/([1-9]0+) ([0-9]+)/);
                                if (mb)
                                {
                                    let sumb = Number(mb[1]) + Number(mb[2]);
                                    numVersion = numVersion.replace(/[1-9]0+ [0-9]+/, String(sumb));
                                }
                                else
                                {
                                    break;
                                }
                            }
                        }

                        //A few other tweaks
                        numVersion = numVersion.replace(/([0-9]) ([0-9]) ([0-9]) ([0-9])/g, "$1$2$3$4");
                        if ((tag == "245" || tag == "830") && code == "n") {
                            while (numVersion.match(/[0-9] [0-9]/)) {
                                numVersion = numVersion.replace(/([0-9]) ([0-9])/, "$1$2");
                            }
                        }
                    }
                    if (useNumVersion)
                    {
                        outputString += numVersion;
                    }
                    else
                    {
                        outputString += textVersion;
                    }
                    //if the end of the string is not reached, backtrack to the delimiter after the last numerical token
                    //(i.e. two tokens ago)
                    if (j < n - 1)
                    {
                        i = j - 2;
                    }
                    else //we are at the end of the string, so we are done!
                    {
                        i = j;
                    }
                    break;
                }
                //this is run when we are not yet at the end of the string and have not yet reached a non-numerical token
                //This is identical to the code that is run above when the last token is numeric.
                if (j % 2 == 0)
                {
                    let m = tokj.match(numToken_re);
                    textVersion += m[1];
                    if (m[2]== "")
                    {
                        numVersion += m[1];
                    }
                    else
                    {
                        numVersion += m[2];
                    }
                }
                else //a delimiter, just tack it on.
                {
                    textVersion += tokj;
                    numVersion += tokj;
                }
            }
        }
        else // the outer loop has encountered a non-numeric token or delimiter, just tack it on.
        {
            outputString += toki;
        }
    }
    return outputString;
 }