mybase 1.1.47 → 1.1.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.47",
+  "version": "1.1.49",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/models/Timespan.d.ts

@@ -15,6 +15,7 @@ export declare class Timespan {
     static days(days: number): Timespan;
     static weeks(weeks: number): Timespan;
     static months(months: number): Timespan;
+    static years(years: number): Timespan;
     add(timespan: Timespan): Timespan;
     subtract(timespan: Timespan): Timespan;
     toJSON(): {

package/ts/models/Timespan.js

@@ -47,6 +47,9 @@ class Timespan {
     static months(months) {
         return new Timespan(months * 30 * 24 * 60 * 60 * 1000);
     }
+    static years(years) {
+        return new Timespan(years * 365 * 24 * 60 * 60 * 1000);
+    }
     add(timespan) {
         return new Timespan(this.ms + timespan.ms);
     }

package/ts/models/Timespan.ts

@@ -58,6 +58,10 @@ export class Timespan {
         return new Timespan(months * 30 * 24 * 60 * 60 * 1000)
     }
 
+    static years(years: number): Timespan {
+        return new Timespan(years * 365 * 24 * 60 * 60 * 1000)
+    }
+
     add(timespan: Timespan): Timespan {
         return new Timespan(this.ms + timespan.ms)
     }

package/ts/models/Unixtime.d.ts

@@ -22,8 +22,8 @@ export declare class Unixtime {
     addDays(days?: number): Unixtime;
     addMonths(months?: number): Unixtime;
     addYears(years?: number): Unixtime;
-    yyyymmdd(): string;
-    yyymmddhh(): string;
+    yyyymmdd(seperator?: string): string;
+    yyyymmddhh(seperator?: string): string;
     /**
     @deprecated use 'day' instead
     */
@@ -42,6 +42,16 @@ export declare class Unixtime {
     elapsedSeconds(): number;
     elapsedMinutes(): number;
     clone(): Unixtime;
+    /**
+     * @param max maximum timespan to subtract
+     * @returns returns random time in the past within given timespan
+     */
+    static randomPast(max?: Timespan, base?: Unixtime): Unixtime;
+    /**
+     * @param max maximum timespan to add
+     * @returns returns random time in the future within given timespan
+     */
+    static randomFuture(max?: Timespan, base?: Unixtime): Unixtime;
     static fromYYYYMMDD(value: string): Unixtime;
     static try(value: Date | string | number): Unixtime | null;
 }

package/ts/models/Unixtime.js

@@ -87,23 +87,23 @@ class Unixtime {
         this.value.setUTCFullYear(this.year + years);
         return this;
     }
-    yyyymmdd() {
+    yyyymmdd(seperator = "") {
         let mm = this.month;
         let dd = this.day;
         return [this.value.getFullYear(),
             (mm > 9 ? '' : '0') + mm,
-            (dd > 9 ? '' : '0') + dd
-        ].join('');
+            (dd > 9 ? '' : '0') + dd,
+        ].join(seperator);
     }
-    yyymmddhh() {
+    yyyymmddhh(seperator = "") {
         let mm = this.month;
         let dd = this.day;
         let hh = this.hours;
         return [this.year,
             (mm > 9 ? '' : '0') + mm,
             (dd > 9 ? '' : '0') + dd,
-            (hh > 9 ? '' : '0') + hh
-        ].join('');
+            (hh > 9 ? '' : '0') + hh,
+        ].join(seperator);
     }
     /**
     @deprecated use 'day' instead
@@ -139,6 +139,20 @@ class Unixtime {
     clone() {
         return new Unixtime(this.toLongUnixtime());
     }
+    /**
+     * @param max maximum timespan to subtract
+     * @returns returns random time in the past within given timespan
+     */
+    static randomPast(max = Timespan_1.Timespan.years(1), base = Unixtime.now()) {
+        return base.addSeconds(Math.random() * max.seconds * -1);
+    }
+    /**
+     * @param max maximum timespan to add
+     * @returns returns random time in the future within given timespan
+     */
+    static randomFuture(max = Timespan_1.Timespan.years(1), base = Unixtime.now()) {
+        return base.addSeconds(Math.random() * max.seconds);
+    }
     static fromYYYYMMDD(value) {
         if (value.length != 8)
             throw new Error('Invalid yyyymmdd value');

package/ts/models/Unixtime.test.ts

@@ -1,3 +1,4 @@
+import { Timespan } from './Timespan';
 import { Unixtime } from './Unixtime';
 
 describe('Unixtime', () => {
@@ -123,6 +124,40 @@ describe('Unixtime', () => {
     expect(unixtime.toISOString()).toEqual('2024-10-11T00:00:00.000Z');
   })
 
+  it('yyyymmddhh should return correct values',() => {
+    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
+    expect(unixtime.yyyymmdd()).toEqual('20241011');
+    expect(unixtime.yyyymmddhh()).toEqual('2024101112');
+    // should also work with optional seperators
+    expect(unixtime.yyyymmddhh('-')).toEqual('2024-10-11-12');
+  })
+
+  it('randomPast should return random time in the past', () => {
+    const end = Unixtime.now()
+    const begin = end.clone().addYears(-1)
+    for(let i=0;i<100000;i++) {
+      const rand = Unixtime.randomPast(Timespan.years(1))
+      expect(rand.toLongUnixtime()).toBeGreaterThan(begin.toLongUnixtime());
+      expect(rand.toLongUnixtime()).toBeLessThan(end.toLongUnixtime());
+    }
+  })
+
+  it('randomFuture should return random time in the future within given timespan of 1 year', () => {
+    const begin = Unixtime.now()
+    const end = begin.clone().addYears(1)
+    for(let i=0;i<100000;i++) {
+      const rand = Unixtime.randomFuture(Timespan.years(1))
+      expect(rand.toLongUnixtime()).toBeGreaterThan(begin.toLongUnixtime());
+      expect(rand.toLongUnixtime()).toBeLessThan(end.toLongUnixtime());
+    }
+  })
+
+  it('yyyymmdd should work as designed',() => {
+    const unixtime = new Unixtime("2024-10-11T12:13:14Z");
+    expect(unixtime.yyyymmdd()).toEqual('20241011');
+    expect(unixtime.yyyymmdd('-')).toEqual('2024-10-11');
+  })
+
   it('fromYYYYMMDD should throw error when invalid date', () => {
     expect(() => Unixtime.fromYYYYMMDD('20243131')).toThrow('Invalid month');
     expect(() => Unixtime.fromYYYYMMDD('20241233')).toThrow('Invalid day');

package/ts/models/Unixtime.ts

@@ -107,24 +107,24 @@ export class Unixtime {
         return this
     }
 
-    public yyyymmdd(): string {
+    public yyyymmdd(seperator: string=""): string {
         let mm = this.month
         let dd = this.day
         return [this.value.getFullYear(),
         (mm > 9 ? '' : '0') + mm,
-        (dd > 9 ? '' : '0') + dd
-        ].join('')
+        (dd > 9 ? '' : '0') + dd,
+        ].join(seperator)
     }
 
-    public yyymmddhh(): string {
+    public yyyymmddhh(seperator: string=""): string {
         let mm = this.month
         let dd = this.day
         let hh = this.hours
         return [this.year,
         (mm > 9 ? '' : '0') + mm,
         (dd > 9 ? '' : '0') + dd,
-        (hh > 9 ? '' : '0') + hh
-        ].join('')
+        (hh > 9 ? '' : '0') + hh,
+        ].join(seperator)
     }
 
     /**
@@ -171,6 +171,21 @@ export class Unixtime {
         return new Unixtime(this.toLongUnixtime())
     }
 
+    /**
+     * @param max maximum timespan to subtract
+     * @returns returns random time in the past within given timespan 
+     */
+    static randomPast(max: Timespan=Timespan.years(1), base: Unixtime=Unixtime.now()): Unixtime {
+        return base.addSeconds(Math.random()*max.seconds*-1)
+    }
+
+    /**
+     * @param max maximum timespan to add
+     * @returns returns random time in the future within given timespan
+     */
+    static randomFuture(max: Timespan=Timespan.years(1), base: Unixtime=Unixtime.now()): Unixtime {
+        return base.addSeconds(Math.random()*max.seconds)
+    }
 
     static fromYYYYMMDD(value: string): Unixtime {
         if (value.length != 8) throw new Error('Invalid yyyymmdd value')