@claspo/common 7.3.1-dev.1 → 7.3.1-dev.2

package/src/velocity/SysVelocityContext.ts

@@ -0,0 +1,129 @@
+type NumberLike = number | string;
+
+export interface SysVelocityContextI {
+  mathTool: {
+    add: (a: NumberLike, b: NumberLike) => number;
+    sub: (a: NumberLike, b: NumberLike) => number;
+    mul: (a: NumberLike, b: NumberLike) => number;
+    div: (a: NumberLike, b: NumberLike) => number;
+  };
+  stringTool: {
+    equalsIgnoreCase: (a: string, b: string) => boolean;
+  };
+  numberTool: {
+    integer: (a: NumberLike) => number;
+    format: (f: string | null, v: NumberLike) => string;
+    number: (v: NumberLike, separator?: string, precision?: number) => string;
+  };
+  dateTool: {
+    currentDate: (format?: string) => string | number;
+    currentTimeStamp: () => number;
+    formatDate: (format: string | null, date: Date | string | number) => string | number;
+  };
+}
+
+export default class SysVelocityContext {
+
+  create(): SysVelocityContextI {
+    return {
+      mathTool: {
+        add: function(a: NumberLike, b: NumberLike): number {
+          return Number(a) + Number(b);
+        },
+        sub: function(a: NumberLike, b: NumberLike): number {
+          return (a as number) - (b as number);
+        },
+        mul: function(a: NumberLike, b: NumberLike): number {
+          return (a as number) * (b as number);
+        },
+        div: function(a: NumberLike, b: NumberLike): number {
+          return (a as number) / (b as number);
+        }
+      },
+      stringTool: {
+        equalsIgnoreCase: function(a: string, b: string): boolean {
+          return String(a).toLowerCase() === String(b).toLowerCase();
+        },
+      },
+      numberTool: {
+        integer: function(a: NumberLike): number {
+          return Math.floor(a as number);
+        },
+        format: function(f: string | null, v: NumberLike): string {
+          const precision = (f || '').split('.')[1];
+          return Number(v).toFixed((precision || '').length);
+        },
+        number: function(v: NumberLike, separator: string = ',', precision: number = 3): string {
+          return Number(v)
+            .toFixed(precision)
+            .replace(new RegExp(`[.]0{${precision}}`), '')
+            .split('.')
+            .map((item: string, i: number) => {
+              if (i === 0) {
+                return item
+                  .split('')
+                  .reverse()
+                  .join('')
+                  .split('')
+                  .map((char: string, i: number) => {
+                    if (i % 3 === 0 && i !== 0) {
+                      char += separator;
+                      return char;
+                    }
+                    return char;
+                  })
+                  .reverse()
+                  .join('');
+              } else if (i === 1) {
+                return item;
+              }
+              return undefined;
+            })
+            .join('.');
+        }
+      },
+      dateTool: {
+        currentDate: function(format?: string): string | number {
+          return this.formatDate(format || 'ISO', new Date());
+        },
+        currentTimeStamp: function(): number {
+          return this.formatDate(null, new Date()) as number;
+        },
+        formatDate: function(format: string | null, date: Date | string | number): string | number {
+          const formatNumberLess10 = (number: number): string => number < 9 ? `0${number}` : `${number}`;
+          const dateObject = new Date(date);
+          if (dateObject.toString() === 'Invalid Date') {
+            return date as string;
+          }
+          if (format === 'ISO') {
+            return dateObject.toISOString();
+          }
+          if (!format || typeof format !== 'string') {
+            return dateObject.getTime();
+          }
+          const parsedFormat = format.split(' ');
+          let result = '';
+          parsedFormat.forEach((piece: string) => {
+            const upperPiece = piece.toUpperCase();
+            result = result.length === 0 ? result : result + ' ';
+            if (upperPiece.includes('HH')) {
+              result += upperPiece
+                .replace('HH', formatNumberLess10(dateObject.getHours()))
+                .replace('MM', formatNumberLess10(dateObject.getMinutes()))
+                .replace('SS', formatNumberLess10(dateObject.getSeconds()))
+            }
+            if (upperPiece.includes('YYYY') || upperPiece.includes('DD')) {
+              result += upperPiece
+                .replace('YYYY', String(dateObject.getFullYear()))
+                .replace('DD', formatNumberLess10(dateObject.getDate()))
+                .replace('MM', formatNumberLess10(dateObject.getMonth() + 1));
+            }
+          });
+          return result;
+        }
+      }
+    }
+
+  }
+
+}

package/src/velocity/SysVelocityRenderer.spec.ts

@@ -0,0 +1,36 @@
+import SysVelocityRenderer from "./SysVelocityRenderer";
+import SysVelocityContext from "./SysVelocityContext";
+
+describe('SysVelocityRenderer', function () {
+  const baseCtx = new SysVelocityContext().create();
+  const instance = new SysVelocityRenderer();
+
+  const context = {
+    "FIRSTNAME": "Kate",
+    "nestedObject": {
+      "prop1": "value1"
+    },
+    "array": [
+      {
+        "el": 1
+      },
+      {
+        "el": 2
+      }
+    ]
+  };
+  const render = (template: string) => instance.render(template, {...baseCtx, data: context});
+
+  it('should support syntax', function () {
+
+    expect(render('$data.get("FIRSTNAME")')).toEqual("Kate");
+    expect(render('$data.get("nestedObject").get("prop1")')).toEqual("value1");
+    expect(render('$data.nestedObject.prop1')).toEqual("value1");
+    expect(render('#foreach($item in $!data.get(\'array\'))$item.el#end')).toEqual("12");
+  });
+
+  it('should have sys ctx', function () {
+
+    expect(render('$mathTool.add(1,1)')).toEqual("2");
+  });
+});

package/src/velocity/SysVelocityRenderer.ts

@@ -0,0 +1,11 @@
+// @ts-ignore
+import * as Velocity from 'velocityjs';
+import SysVelocityContext from "./SysVelocityContext";
+
+const sysCtx = new SysVelocityContext().create();
+
+export default class SysVelocityRenderer {
+  render(template: string, context: Record<string, any>): string {
+    return Velocity.render(template, {...sysCtx, ...context});
+  }
+}