updatedeps: make methods usable without class

Author: Sven Ulrich

.gitignore

@@ -1,7 +1,6 @@
 node_modules
 .vscode/*
 
-dist/*.js
 
 # Compiled source #
 ###################
@@ -12,7 +11,8 @@ dist/*.js
 *.o
 *.so
 *.min.js
-
+*.d.ts.map
+dist
 # Packages #
 ############
 # it's better to unpack these files and commit the raw source
@@ -40,4 +40,4 @@ dist/*.js
 .Spotlight-V100
 .Trashes
 ehthumbs.db
-Thumbs.db
+Thumbs.db

README.md

@@ -10,50 +10,51 @@
 
 
 ```typescript
- import { String, StringBuilder } from 'typescript-string-operations';
+ import { StringBuilder, join, format, isNullOrWhiteSpace } from 'typescript-string-operations';
  ```
 
-I recently got feedback that sometimes there are issues when using `String`, since its actually replacing the native `String` object from JavaScript. You can use `$String` instead.
+When migrating from Version 1.4.1 or lower, you can also import the class `String`. Using this String class would override the native `String` object from JavaScript. We will remove this declaration with the next major release
 
 ```typescript
- import { $String } from 'typescript-string-operations';
+ import { String } from 'typescript-string-operations';
 ```
 
 #### USAGE:
 
 ### String.empty
 ```typescript
-var id = String.empty;
+var id = empty; // or String.empty
+// output: id = '';
 ```
 
 ### String.isNullOrWhiteSpace():
 ```typescript
 var id = image.GetId();
-if(String.isNullOrWhiteSpace(id))
+if(isNullOrWhiteSpace(id)) // String.isNullOrWhiteSpace(id)
 	return image;
 ```
 ### String.format():
 
 ```typescript
 var id = image.GetId()
-String.format("image_{0}.jpg", id)
+format("image_{0}.jpg", id) // or String.format()
 output: "image_2db5da20-1c5d-4f1a-8fd4-b41e34c8c5b5.jpg";
 ```
 
 Specifier available!
 ```typescript
-var value = String.format("{0:L}", "APPLE"); //output "apple"
+var value = format("{0:L}", "APPLE"); //output "apple"
 
-value = String.format("{0:U}", "apple"); // output "APPLE"
+value = format("{0:U}", "apple"); // output "APPLE"
 
-value = String.format("{0:d}", "2017-01-23 00:00"); //output "23.01.2017"
+value = format("{0:d}", "2017-01-23 00:00"); //output "23.01.2017"
 
-value = String.format("{0:s}", "21.03.2017 22:15:01") //output "2017-03-21T22:15:01"
+value = format("{0:s}", "21.03.2017 22:15:01") //output "2017-03-21T22:15:01"
 
-value = String.format("{0:n}", 1000000);
+value = format("{0:n}", 1000000);
 //output "1.000.000"
 
-value = String.format("{0:00}", 1);
+value = format("{0:00}", 1);
 //output "01"
 ```
 
@@ -67,7 +68,7 @@ fruit.color = "RED";
 fruit.shippingDate = new Date(2018, 1, 1);
 fruit.amount = 10000;
 
-String.format("the {type:U} is {color:L} shipped on {shippingDate:s} with an amount of {amount:n}", fruit);
+format("the {type:U} is {color:L} shipped on {shippingDate:s} with an amount of {amount:n}", fruit);
 // output: the APPLE is red shipped on 2018-01-01 with an amount of 10.000
 
 ```
@@ -84,21 +85,21 @@ String.format("the {type:U} is {color:L} shipped on {shippingDate:s} with an amo
 
 
 
-### String.Join():
+### String.join():
 
 ```typescript
-var value = String.join("; ", "Apple", "Banana");
+var value = join("; ", "Apple", "Banana"); // or String.join()
 //output: "Apple; Banana";
 ```
 #### OR
 
 ```typescript
  let object = { Name: "Foo", Value: "Bar" };
- var value = String.join('.', object);
+ var value = join('.', object);
 //output: "Foo.Bar";
 
 var array = ['Apple', 'Banana']
-var value = String.join("; ", array);
+var value = join("; ", array);
 //output: "Apple; Banana";
 ```
 
@@ -140,8 +141,8 @@ var fruits = builder.ToString();
 | Method                    |  Type       |       Description          | Parameter  |
 | :------------------------:|:-----------:|:--------------------------:|:----------:|
 |  `Append`                 | `Method`    |    appends a string.       | `value`    |
-|  `AppendFormat`           | `Method`    |    see description for `String.format()`| `format`, `args`|
+|  `AppendFormat`           | `Method`    |    see description for `format()`| `format`, `args`|
 |  `AppendLine`             | `Method`    |    appends a string in a new line. | `format`, `args`|
-|  `AppendLineFormat`       | `Method`    |    like `String.format()` in a new line | `format`, `args`|
+|  `AppendLineFormat`       | `Method`    |    like `format()` in a new line | `format`, `args`|
 |  `Clear`		            | `Method`    |    clears the `StringBuilder`   |       |
 |  `ToString`	            | `Method`    |    creates the actual string.  |       |

index.d.ts

@@ -1,21 +1,47 @@
 const EOL = '\r\n';
 
-export class $String {
+export const empty = '';
+
+export function isNullOrWhiteSpace(value: string | null | undefined): boolean {
+    return String.isNullOrWhiteSpace(value);
+}
+
+export function join(delimiter: string, ...args: (string | object | Array<any>)[]): string {
+    return String.join(delimiter, ...args);
+}
+
+export function format(format: string, ...args: any[]): string {
+    return String.format(format, ...args);
+}
+
+export class String {
     private static readonly regexNumber = /{(\d+(:\w*)?)}/g;
     private static readonly regexObject = /{(\w+(:\w*)?)}/g;
     public static empty = '';
+    /**
+     * @deprecated The property should not be used, and will be removed in future versions! Use `String.empty` instead.
+    */
     public static Empty = '';
 
+    /**
+     * @deprecated The method should not be used, and will be removed in future versions! Use `String.isNullOrWhiteSpace()` instead.
+    */
     public static IsNullOrWhiteSpace(value: string | null | undefined): boolean {
-        return $String.isNullOrWhiteSpace(value);
+        return String.isNullOrWhiteSpace(value);
     }
 
+    /**
+     * @deprecated The method should not be used, and will be removed in future versions! Use `String.join()` instead.
+    */
     public static Join(delimiter: string, ...args: (string | object | Array<any>)[]): string {
-        return $String.join(delimiter, ...args);
+        return String.join(delimiter, ...args);
     }
 
+    /**
+     * @deprecated The method should not be used, and will be removed in future version!s Use `String.format()` instead.
+    */
     public static Format(format: string, ...args: any[]): string {
-        return $String.format(format, ...args);
+        return String.format(format, ...args);
     }
 
     public static isNullOrWhiteSpace(value: string | null | undefined): boolean {
@@ -36,7 +62,7 @@ export class $String {
         try {
             const firstArg = args[0];
             if (Array.isArray(firstArg) || firstArg instanceof Array) {
-                let tempString = $String.empty;
+                let tempString = String.empty;
 
                 for (let i = 0; i < firstArg.length; i++) {
                     const current = firstArg[i];
@@ -51,7 +77,7 @@ export class $String {
                 return tempString;
             }
             else if (typeof firstArg === 'object') {
-                let tempString = $String.empty;
+                let tempString = String.empty;
                 const objectArg = firstArg;
                 const keys = Object.keys(firstArg); //get all Properties of the Object as Array
                 keys.forEach(element => { tempString += (<any>objectArg)[element] + delimiter; });
@@ -61,29 +87,29 @@ export class $String {
 
             const stringArray = <string[]>args;
 
-            return $String.joinString(delimiter, ...stringArray);
+            return String.joinString(delimiter, ...stringArray);
         }
         catch (e) {
             console.log(e);
-            return $String.empty;
+            return String.empty;
         }
     }
 
     public static format(format: string, ...args: any[]): string {
         try {
-            if (format.match($String.regexNumber)) {
-                return $String.formatString($String.regexNumber, format, args);
+            if (format.match(String.regexNumber)) {
+                return String.formatString(String.regexNumber, format, args);
             }
 
-            if (format.match($String.regexObject)) {
-                return $String.formatString($String.regexObject, format, args, true);
+            if (format.match(String.regexObject)) {
+                return String.formatString(String.regexObject, format, args, true);
             }
 
             return format;
         }
         catch (e) {
             console.log(e);
-            return $String.empty;
+            return String.empty;
         }
     }
 
@@ -107,8 +133,8 @@ export class $String {
                 return arg;
             }
 
-            arg = $String.parsePattern(match, arg);
-            return typeof arg != 'undefined' && arg != null ? arg : $String.empty;
+            arg = String.parsePattern(match, arg);
+            return typeof arg != 'undefined' && arg != null ? arg : String.empty;
         });
     }
 
@@ -124,19 +150,19 @@ export class $String {
             }
             case 'd': {
                 if (typeof (arg) === 'string') {
-                    return $String.getDisplayDateFromString(arg);
+                    return String.getDisplayDateFromString(arg);
                 }
                 else if (arg instanceof Date) {
-                    return $String.format('{0:00}.{1:00}.{2:0000}', arg.getDate(), arg.getMonth(), arg.getFullYear());
+                    return String.format('{0:00}.{1:00}.{2:0000}', arg.getDate(), arg.getMonth(), arg.getFullYear());
                 }
                 break;
             }
             case 's': {
                 if (typeof (arg) === 'string') {
-                    return $String.getSortableDateFromString(arg);
+                    return String.getSortableDateFromString(arg);
                 }
                 else if (arg instanceof Date) {
-                    return $String.format('{0:0000}-{1:00}-{2:00}', arg.getFullYear(), arg.getMonth(), arg.getDate());
+                    return String.format('{0:0000}-{1:00}-{2:00}', arg.getFullYear(), arg.getMonth(), arg.getDate());
                 }
                 break;
             }
@@ -152,16 +178,16 @@ export class $String {
                 let parts = numberparts;
 
                 if (numberparts.length > 1) {
-                    parts = [$String.joinString('', ...(numberparts.splice(0, numberparts.length - 1))), numberparts[numberparts.length - 1]];
+                    parts = [String.joinString('', ...(numberparts.splice(0, numberparts.length - 1))), numberparts[numberparts.length - 1]];
                 }
 
                 const integer = parts[0];
 
                 const mod = integer.length % 3;
-                let output = (mod > 0 ? (integer.substring(0, mod)) : $String.empty);
+                let output = (mod > 0 ? (integer.substring(0, mod)) : String.empty);
 
                 const remainingGroups = integer.substring(mod).match(/.{3}/g);
-                output = output + '.' + $String.join('.', remainingGroups);
+                output = output + '.' + String.join('.', remainingGroups);
                 arg = output + (parts.length > 1 ? ',' + parts[1] : '');
                 return arg;
             }
@@ -176,8 +202,8 @@ export class $String {
             }
         }
 
-        if ((typeof (arg) === 'number' || !isNaN(arg)) && !isNaN(+match) && !$String.isNullOrWhiteSpace(arg)) {
-            return $String.formatNumber(arg, match);
+        if ((typeof (arg) === 'number' || !isNaN(arg)) && !isNaN(+match) && !String.isNullOrWhiteSpace(arg)) {
+            return String.formatNumber(arg, match);
         }
 
         return arg;
@@ -212,7 +238,7 @@ export class $String {
         }
 
         const times = splitted[splitted.length - 1].split(' ');
-        let time = $String.empty;
+        let time = String.empty;
         if (times.length > 1) {
             time = times[times.length - 1];
         }
@@ -222,7 +248,7 @@ export class $String {
         const day = splitted[splitted.length - 3];
         let result = `${year}-${month}-${day}`;
 
-        if (!$String.isNullOrWhiteSpace(time) && time.length > 1) {
+        if (!String.isNullOrWhiteSpace(time) && time.length > 1) {
             result += `T${time}`;
         }
         else {
@@ -246,17 +272,17 @@ export class $String {
     }
 
     private static joinString(delimiter: string, ...args: string[]): string {
-        let temp = $String.empty;
+        let temp = String.empty;
         for (let i = 0; i < args.length; i++) {
-            if ((typeof args[i] == 'string' && $String.isNullOrWhiteSpace(args[i]))
+            if ((typeof args[i] == 'string' && String.isNullOrWhiteSpace(args[i]))
                 || (typeof args[i] != 'number' && typeof args[i] != 'string')) {
                 continue;
             }
 
             const arg = '' + args[i];
             temp += arg;
             for (let i2 = i + 1; i2 < args.length; i2++) {
-                if ($String.isNullOrWhiteSpace(args[i2])) {
+                if (String.isNullOrWhiteSpace(args[i2])) {
                     continue;
                 }
 
@@ -270,21 +296,20 @@ export class $String {
     }
 }
 
-export class String extends $String { }
 
 export class StringBuilder {
     public Values: string[];
 
     constructor(value = '') {
         this.Values = [];
 
-        if (!$String.isNullOrWhiteSpace(value)) {
+        if (!String.isNullOrWhiteSpace(value)) {
             this.Values = new Array(value);
         }
     }
 
     public toString() {
-        return this.Values.join($String.empty);
+        return this.Values.join(String.empty);
     }
 
     public ToString() {
@@ -308,15 +333,15 @@ export class StringBuilder {
     }
 
     public appendFormat(format: string, ...args: any[]) {
-        this.Values.push($String.format(format, ...args));
+        this.Values.push(String.format(format, ...args));
     }
 
     public AppendFormat(format: string, ...args: any[]) {
         this.appendFormat(format, ...args);
     }
 
     public appendLineFormat(format: string, ...args: any[]) {
-        this.Values.push(EOL + $String.format(format, ...args));
+        this.Values.push(EOL + String.format(format, ...args));
     }
 
     public AppendLineFormat(format: string, ...args: any[]) {