decova-dotnet-developer/dist/src/String/XString.js

This package provides fundumentals that a .net developer may miss while working with Typescript, whether they are missing functinalities or funcionalities provided in a non-elegant design in javascript. Bad naming, bad design of optional parameters, non-c

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.XString = exports.s = exports.xs = void 0;
const List_1 = require("../List/List");
function xs(str) {
    if (str instanceof XString)
        return str;
    return new XString(str);
}
exports.xs = xs;
function s(str) {
    if (str instanceof XString)
        return str.Value;
    return str;
}
exports.s = s;
class XString {
    constructor(Value) {
        this.Value = Value;
    }
    get Length() {
        return this.Value.length;
    }
    PadRight(totalWidth, paddingChar) {
        paddingChar = s(paddingChar);
        if (paddingChar.length !== 1)
            throw "Only one character expected in paddingChar";
        let countLeft = totalWidth - this.Length;
        for (let x = 0; x < countLeft; x++) {
            this.Value = this.Value + paddingChar;
        }
        return this;
    }
    PadLeft(totalWidth, paddingChar) {
        paddingChar = s(paddingChar);
        if (paddingChar.length != 1)
            throw "Only one character expected in paddingChar";
        let countLeft = totalWidth - this.Length;
        for (let x = 0; x < countLeft; x++) {
            this.Value = this.Value + paddingChar;
        }
        return this;
    }
    ;
    Substring(startIndex, length = undefined) {
        if (startIndex >= this.Length)
            throw new Error("Index out of range");
        if (length == undefined) {
            length = this.Length - 1 - startIndex;
        }
        else {
            if (startIndex + length > this.Length)
                throw "String.Substring() index out of range";
        }
        let lastIndex = startIndex + length;
        return this.Value.slice(startIndex, lastIndex);
    }
    ;
    Remove(startIndex, length) {
        if (length <= 0)
            throw new Error("Invalid argument length");
        if (startIndex + length - 1 > this.Length)
            throw new Error("Out of range.");
        let leftPart = this.Substring(0, startIndex);
        let rightPart = this.Substring(startIndex + length, this.Length - startIndex - length);
        return xs(leftPart + rightPart);
    }
    ;
    Contains(substr) {
        if (substr == null || substr == "")
            throw new Error("substr cannot be null or empty");
        substr = s(substr);
        return this.Value.includes(substr, 0);
    }
    ;
    Insert(index, value) {
        if (index < 0 || index >= this.Value.length)
            throw new Error('Out of range');
        if (value != null)
            value = s(value);
        return xs(`${this.Substring(0, index)}${value}${this.Substring(index)}`);
    }
    ToString() {
        return this.Value;
    }
    IsNullOrEmpty() {
        if (this.Value == null)
            return true;
        if (this.Value === "")
            return true;
        return false;
    }
    IsNullOrWhiteSpace() {
        if (this.Value == null)
            return true;
        if (new RegExp(/^\s*$/g).test(this.Value))
            return true;
        else
            return false;
    }
    static Join(separator, parts) {
        if (parts.length == 0)
            return new XString('');
        separator = s(separator);
        if (parts[0] instanceof XString)
            parts = new List_1.List(parts)
                .Select(x => x.Value).Array;
        return xs(parts.join(separator));
    }
    StartsWith(str) {
        return this.Value.startsWith(str);
    }
    EndsWith(str) {
        return this.Value.endsWith(str);
    }
    IndexOf(subStr, startSearchFromIndex) {
        if (subStr == null)
            throw new Error("subStr cannot be null");
        if (subStr instanceof XString)
            subStr = subStr.Value;
        if (startSearchFromIndex < 0 || startSearchFromIndex >= subStr.length)
            throw new Error("Index out of range");
        return this.Value.indexOf(subStr, startSearchFromIndex);
    }
    LastIndexOf(subStr, startSearchFromIndex) {
        if (subStr == null)
            throw new Error("subStr cannot be null");
        if (subStr instanceof XString)
            subStr = subStr.Value;
        if (startSearchFromIndex < 0 || startSearchFromIndex >= subStr.length)
            throw new Error("Index out of range");
        return this.Value.lastIndexOf(subStr, startSearchFromIndex);
    }
    ReplaceOnce(toReplace, replacement) {
        if (toReplace instanceof XString)
            toReplace = toReplace.Value;
        if (replacement instanceof XString)
            replacement = replacement.Value;
        this.Value = this.Value.replace(toReplace, replacement);
        return this;
    }
    ReplaceAll(toReplace, replacement) {
        if (toReplace instanceof XString)
            toReplace = toReplace.Value;
        if (replacement instanceof XString)
            replacement = replacement.Value;
        if (toReplace == replacement)
            this;
        while (this.Value.indexOf(toReplace) >= 0) {
            this.Value = this.Value.replace(toReplace, replacement);
        }
        return this;
    }
    toString() {
        return this.Value;
    }
}
exports.XString = XString;
//# sourceMappingURL=XString.js.map