@shaxpir/duiduidui-models 1.0.1 → 1.1.0

package/dist/util/NumberFormat.d.ts

@@ -1,14 +0,0 @@
-export declare class NumberFormat {
-    private static readonly ORDINAL_REGEX;
-    private static readonly NUMERIC_WORD_SEQUENCE;
-    private static readonly ROMAN_NUMERALS;
-    static commas(value: number, keepFractions: boolean): string;
-    static ordinal(value: number): string;
-    static isOrdinal(text: string): boolean;
-    static dollarsFromCents(value: number): string;
-    static percent(value: number, fractionDigits?: number): string;
-    static text(value: number): string;
-    static findNumericWordSequence(text: string): string;
-    static findRomanNumerals(text: string): string;
-    static asHex(value: number, padToLength?: number): string;
-}

package/dist/util/NumberFormat.js

@@ -1,224 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumberFormat = void 0;
-class NumberFormat {
-    static commas(value, keepFractions) {
-        if (!Number.isFinite(value)) {
-            return "0"; //  We never want to show "NaN" or "Infinity" in shaxpir. Zero is always preferable.
-        }
-        let original = value;
-        let isNegative = value < 0;
-        let absValue = Math.abs(value);
-        let floorValue = Math.floor(absValue);
-        let v = floorValue;
-        let formatted = "";
-        if (v === 0) {
-            formatted = "0";
-        }
-        while (v > 0) {
-            if (formatted.length > 0) {
-                formatted = "," + formatted;
-            }
-            let remainder = (v % 1000);
-            v = Math.floor(v / 1000);
-            if (v > 0) {
-                if (remainder < 10) {
-                    formatted = "00" + remainder + formatted;
-                }
-                else if (remainder < 100) {
-                    formatted = "0" + remainder + formatted;
-                }
-                else {
-                    formatted = remainder + formatted;
-                }
-            }
-            else {
-                formatted = remainder + formatted;
-            }
-        }
-        if (keepFractions && absValue !== floorValue) {
-            formatted += "." + original.toString().split('.')[1];
-        }
-        if (isNegative) {
-            formatted = "-" + formatted;
-        }
-        return formatted;
-    }
-    static ordinal(value) {
-        if (value == 1 || (value % 10 == 1 && value != 11)) {
-            return "st";
-        }
-        else if (value == 2 || (value % 10 == 2 && value != 12)) {
-            return "nd";
-        }
-        else if (value == 3 || (value % 10 == 3 && value != 13)) {
-            return "rd";
-        }
-        else {
-            return "th";
-        }
-    }
-    static isOrdinal(text) {
-        return NumberFormat.ORDINAL_REGEX.test(text);
-    }
-    static dollarsFromCents(value) {
-        let dollars = Math.floor(value / 100);
-        let cents = value - (dollars * 100);
-        if (cents === 0) {
-            return "$" + dollars + ".00";
-        }
-        else if (cents < 10) {
-            return "$" + dollars + ".0" + cents;
-        }
-        else {
-            return "$" + dollars + "." + cents;
-        }
-    }
-    static percent(value, fractionDigits = 0) {
-        let numbers = NumberFormat.commas(value * 100, fractionDigits > 0);
-        if (fractionDigits > 0 && value !== 0) {
-            let indexOfDecimal = numbers.lastIndexOf(".");
-            if (indexOfDecimal >= 0) {
-                let numsBeforeDecimal = numbers.substring(0, indexOfDecimal);
-                let numsAfterDecimal = numbers.substring(indexOfDecimal + 1);
-                if (numsAfterDecimal.length > fractionDigits) {
-                    numbers = numsBeforeDecimal + "." + numsAfterDecimal.substring(0, fractionDigits);
-                }
-            }
-        }
-        return numbers + "%";
-    }
-    static text(value) {
-        let isNegative = value < 0;
-        value = Math.abs(Math.round(value));
-        let asText;
-        if (value == 0) {
-            asText = "zero";
-        }
-        else if (value == 1) {
-            asText = "one";
-        }
-        else if (value == 2) {
-            asText = "two";
-        }
-        else if (value == 3) {
-            asText = "three";
-        }
-        else if (value == 4) {
-            asText = "four";
-        }
-        else if (value == 5) {
-            asText = "five";
-        }
-        else if (value == 6) {
-            asText = "six";
-        }
-        else if (value == 7) {
-            asText = "seven";
-        }
-        else if (value == 8) {
-            asText = "eight";
-        }
-        else if (value == 9) {
-            asText = "nine";
-        }
-        else if (value == 10) {
-            asText = "ten";
-        }
-        else if (value == 11) {
-            asText = "eleven";
-        }
-        else if (value == 12) {
-            asText = "twelve";
-        }
-        else if (value == 13) {
-            asText = "thirteen";
-        }
-        else if (value == 14) {
-            asText = "fourteen";
-        }
-        else if (value == 15) {
-            asText = "fifteen";
-        }
-        else if (value == 16) {
-            asText = "sixteen";
-        }
-        else if (value == 17) {
-            asText = "seventeen";
-        }
-        else if (value == 18) {
-            asText = "eighteen";
-        }
-        else if (value == 19) {
-            asText = "nineteen";
-        }
-        else if (value >= 20 && value <= 99) {
-            let tensPlace = Math.floor(value / 10);
-            let onesPlace = value % 10;
-            if (tensPlace == 2) {
-                asText = "twenty";
-            }
-            else if (tensPlace == 3) {
-                asText = "thirty";
-            }
-            else if (tensPlace == 4) {
-                asText = "forty";
-            }
-            else if (tensPlace == 5) {
-                asText = "fifty";
-            }
-            else if (tensPlace == 6) {
-                asText = "sixty";
-            }
-            else if (tensPlace == 7) {
-                asText = "seventy";
-            }
-            else if (tensPlace == 8) {
-                asText = "eighty";
-            }
-            else if (tensPlace == 9) {
-                asText = "ninety";
-            }
-            if (onesPlace !== 0) {
-                asText += "-" + NumberFormat.text(onesPlace);
-            }
-        }
-        else if (value >= 100 && value <= 999) {
-            let hundredsPlace = Math.floor(value / 100);
-            asText = NumberFormat.text(hundredsPlace) + " hundred " + NumberFormat.text(value - (hundredsPlace * 100));
-        }
-        else if (value >= 1000 && value <= 9999) {
-            let thousandsPlace = Math.floor(value / 1000);
-            asText = NumberFormat.text(thousandsPlace) + " thousand " + NumberFormat.text(value - (thousandsPlace * 1000));
-        }
-        if (isNegative) {
-            asText = "minus " + asText;
-        }
-        return asText;
-    }
-    static findNumericWordSequence(text) {
-        let result = NumberFormat.NUMERIC_WORD_SEQUENCE.exec(text);
-        if (result !== null) {
-            return result[0];
-        }
-        return null;
-    }
-    static findRomanNumerals(text) {
-        let result = NumberFormat.ROMAN_NUMERALS.exec(text);
-        if (result !== null) {
-            return result[0];
-        }
-        return null;
-    }
-    static asHex(value, padToLength = 1) {
-        let hex = Math.floor(value).toString(16);
-        while (hex.length < padToLength) {
-            hex = "0" + hex;
-        }
-        return hex;
-    }
-}
-exports.NumberFormat = NumberFormat;
-NumberFormat.ORDINAL_REGEX = /^\d*(?:1st|2nd|3rd|[04-9]th|1[23]th)$/i;
-NumberFormat.NUMERIC_WORD_SEQUENCE = /(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|(?:thir|four|fif|six|seven|eigh|nine)teen|(?:twen|thir|for|fif|six|seven|eigh|nine)ty|[mb]illion|thousand|hundred)(?:(?:\s*(?:\sand\s+|-\s*)(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|(?:thir|four|fif|six|seven|eigh|nine)teen|(?:twen|thir|for|fif|six|seven|eigh|nine)ty|[mb]illion|thousand|hundred)))*/i;
-NumberFormat.ROMAN_NUMERALS = /\b[MDCLXVI]+\b/i;

package/dist/util/Struct.d.ts

@@ -1,4 +0,0 @@
-export declare class Struct {
-    static clone(value: any): any;
-    static equals(a: any, b: any): boolean;
-}

package/dist/util/Struct.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Struct = void 0;
-const rfdc = require("rfdc");
-const isEqual = require("fast-deep-equal");
-const cloneDeep = rfdc();
-class Struct {
-    static clone(value) {
-        return cloneDeep(value);
-    }
-    static equals(a, b) {
-        return isEqual(a, b);
-    }
-}
-exports.Struct = Struct;

package/dist/util/Template.d.ts

@@ -1,16 +0,0 @@
-export declare class TemplateParser {
-    private static TAG_PATTERN;
-    static parse(text: string): Template;
-    private static fromChunks;
-    private static findEndIndex;
-}
-export interface Renderable {
-    render: (params: any) => string;
-}
-export declare class Template implements Renderable {
-    private parts;
-    private name;
-    private negated;
-    constructor(parts: Renderable[], name: string, negated: boolean);
-    render(params: any): string;
-}

package/dist/util/Template.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Template = exports.TemplateParser = void 0;
-const HtmlMarkup_1 = require("../models/markup/HtmlMarkup");
-class TemplateParser {
-    static parse(text) {
-        let chunks = [];
-        let lastEndIndex = 0;
-        let match;
-        while ((match = TemplateParser.TAG_PATTERN.exec(text)) !== null) {
-            let tagText = match[0];
-            let index = match.index;
-            if (index > lastEndIndex) {
-                let textBeforeTag = text.substring(lastEndIndex, index);
-                chunks.push(textBeforeTag);
-            }
-            chunks.push(tagText);
-            lastEndIndex = index + tagText.length;
-        }
-        if (lastEndIndex < text.length) {
-            let textAfterTag = text.substring(lastEndIndex);
-            chunks.push(textAfterTag);
-        }
-        return TemplateParser.fromChunks(chunks, null, false);
-    }
-    static fromChunks(chunks, name, negated) {
-        let parts = [];
-        for (let i = 0, len = chunks.length; i < len; i++) {
-            let chunk = chunks[i];
-            if (!chunk.startsWith("{")) {
-                parts.push(new StringLiteratal(chunk));
-            }
-            else if (chunk.startsWith("{{{")) {
-                if (chunk.endsWith("}}}")) {
-                    let name = chunk.substring(3, chunk.length - 3);
-                    if (name.startsWith("/") || name.startsWith("^") || name.startsWith("#")) {
-                        throw new Error("illegal name for triple-braced template-tag: " + chunk);
-                    }
-                    parts.push(new TemplateTag(name, false));
-                }
-                else {
-                    throw new Error("mismatched braces in template-tag: " + chunk);
-                }
-            }
-            else {
-                if (chunk.endsWith("}}}")) {
-                    throw new Error("mismatched braces in template-tag: " + chunk);
-                }
-                else if (chunk.startsWith("{{#") || chunk.startsWith("{{^")) {
-                    let name = chunk.substring(3, chunk.length - 2);
-                    let negated = chunk.startsWith("{{^");
-                    let endIndex = TemplateParser.findEndIndex(chunks, name, i);
-                    if (endIndex - i > 1) {
-                        let subChunks = chunks.slice(i + 1, endIndex);
-                        let template = TemplateParser.fromChunks(subChunks, name, negated);
-                        parts.push(template);
-                    }
-                    i = endIndex;
-                }
-                else if (chunk.startsWith("{{/")) {
-                    throw new Error("unmatched end-tag: " + chunk);
-                }
-                else {
-                    let name = chunk.substring(2, chunk.length - 2);
-                    parts.push(new TemplateTag(name, true));
-                }
-            }
-        }
-        return new Template(parts, name, negated);
-    }
-    static findEndIndex(chunks, name, startIndex) {
-        for (let i = startIndex + 1; i < chunks.length; i++) {
-            let chunk = chunks[i];
-            if (chunk === "{{/" + name + "}}") {
-                return i;
-            }
-        }
-        throw new Error("can't find end-index for chunk: " + chunks[startIndex]);
-    }
-}
-exports.TemplateParser = TemplateParser;
-TemplateParser.TAG_PATTERN = /\{\{.+?\}?\}\}/g;
-class Template {
-    constructor(parts, name, negated) {
-        this.parts = parts;
-        this.name = name;
-        this.negated = negated;
-    }
-    render(params) {
-        let result = "";
-        if (this.name == null ||
-            (params.hasOwnProperty(this.name) && params[this.name] === !this.negated)) {
-            for (let i = 0, len = this.parts.length; i < len; i++) {
-                let part = this.parts[i];
-                result += part.render(params);
-            }
-        }
-        return result;
-    }
-}
-exports.Template = Template;
-class StringLiteratal {
-    constructor(value) {
-        this.value = value;
-    }
-    render(params) {
-        return this.value;
-    }
-}
-class TemplateTag {
-    constructor(name, escapeHtml) {
-        this.name = name;
-        this.escapeHtml = escapeHtml;
-    }
-    render(params) {
-        if (params.hasOwnProperty(this.name)) {
-            let value = params[this.name];
-            if (value !== null) {
-                let text = "" + value;
-                if (this.escapeHtml) {
-                    text = HtmlMarkup_1.HtmlMarkup.escapeText(text);
-                }
-                return text;
-            }
-        }
-        return "";
-    }
-}

package/dist/util/Text.d.ts

@@ -1,45 +0,0 @@
-export declare class Text {
-    private static readonly WORD_START_CHAR_CLASS;
-    private static readonly WORD_MIDDLE_CHAR_CLASS;
-    private static readonly WORD_END_CHAR_CLASS;
-    private static readonly APOSTROPHE_CHAR_CLASS;
-    private static readonly WORD_POST_APOS_CHAR_CLASS;
-    private static readonly WORD_BOUNDARY_BEFORE;
-    private static readonly WORD_BOUNDARY_AFTER;
-    private static readonly WORD_PATTERN;
-    static readonly WORD_REGEX: RegExp;
-    private static readonly NON_WORD_CHARS;
-    static countWords(text: string): number;
-    static tokenizeWords(text: string, keepSeparators: boolean): string[];
-    static getUniqueWords(text: string): string[];
-    static capitalizeWords(text: string): string;
-    static normalizeText(text: string): string;
-    static normalizeDashes(text: string): string;
-    static makeCurlyQuotes(text: string): string;
-    static normalizeApostrophes(text: string): string;
-    static removeDashes(text: string): string;
-    static removeApostrophes(text: string): string;
-    static removePosessive(text: string): string;
-    static removePlural(word: string): string;
-    static removeSuffixes(word: string, suffixes: string[]): string;
-    static stripNonWordChars(text: string): string;
-    static endsWithAnySuffix(text: string, suffixes: string[]): boolean;
-    static endsWithWordChar(text: string): boolean;
-    static isWordChar(c: string): boolean;
-    static isAllWordChars(text: string): boolean;
-    static hasAnyWordChars(text: string): boolean;
-    static isPunctuation(c: string): boolean;
-    static isAllPunctuation(text: string): boolean;
-    static hasAnyPunctuation(text: string): boolean;
-    static isWhitspace(c: string): boolean;
-    static isAllWhitspace(text: string): boolean;
-    static hasAnyWhitspace(text: string): boolean;
-    static isDigit(c: string): boolean;
-    static isAllDigits(text: string): boolean;
-    static hasAnyDigits(text: string): boolean;
-    static isCapitalLetter(c: string): boolean;
-    static isAllCapitalLetters(text: string): boolean;
-    static hasAnyCapitalLetters(text: string): boolean;
-    private static allCharsMatch;
-    private static anyCharsMatch;
-}