mybase 1.1.20 → 1.1.22

package/package.json

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

package/ts/funcs/getWeekNumber.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWeekNumber = void 0;
+// credit: https://stackoverflow.com/questions/6117814/get-week-of-year-in-javascript-like-in-php
+/* For a given date, get the ISO week number
+ 
+  Based on information at:
+ 
+     THIS PAGE (DOMAIN EVEN) DOESN'T EXIST ANYMORE UNFORTUNATELY
+     http://www.merlyn.demon.co.uk/weekcalc.htm#WNR
+ 
+  Algorithm is to find nearest thursday, it's year
+  is the year of the week number. Then get weeks
+  between that date and the first day of that year.
+ 
+  Note that dates in one year can be weeks of previous
+  or next year, overlap is up to 3 days.
+ 
+  e.g. 2014/12/29 is Monday in week  1 of 2015
+       2012/1/1   is Sunday in week 52 of 2011
+*/
+function getWeekNumber(d = new Date()) {
+    // Copy date so don't modify original
+    const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+    // Set to nearest Thursday: current date + 4 - current day number
+    // Make Sunday's day number 7
+    date.setUTCDate(date.getUTCDate() + 4 - (date.getUTCDay() || 7));
+    // Get first day of year
+    const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+    // Calculate full weeks to nearest Thursday
+    const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    // Return the week number
+    return weekNo;
+}
+exports.getWeekNumber = getWeekNumber;
+//# sourceMappingURL=getWeekNumber.js.map

package/ts/funcs/getWeekNumber.test.ts

@@ -0,0 +1,9 @@
+import { getWeekNumber } from './getWeekNumber'
+
+
+describe('getWeekNumber', () => {
+    it('should return the correct week number', () => {
+        expect(getWeekNumber(new Date('2012-01-01'))).toBe(52)
+        expect(getWeekNumber(new Date('2014-12-30'))).toBe(1)
+    })  
+})

package/ts/funcs/getWeekNumber.ts

@@ -0,0 +1,31 @@
+// credit: https://stackoverflow.com/questions/6117814/get-week-of-year-in-javascript-like-in-php
+/* For a given date, get the ISO week number
+ 
+  Based on information at:
+ 
+     THIS PAGE (DOMAIN EVEN) DOESN'T EXIST ANYMORE UNFORTUNATELY
+     http://www.merlyn.demon.co.uk/weekcalc.htm#WNR
+ 
+  Algorithm is to find nearest thursday, it's year
+  is the year of the week number. Then get weeks
+  between that date and the first day of that year.
+ 
+  Note that dates in one year can be weeks of previous
+  or next year, overlap is up to 3 days.
+ 
+  e.g. 2014/12/29 is Monday in week  1 of 2015
+       2012/1/1   is Sunday in week 52 of 2011
+*/
+export function getWeekNumber(d: Date = new Date()): number {
+    // Copy date so don't modify original
+    const date = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+    // Set to nearest Thursday: current date + 4 - current day number
+    // Make Sunday's day number 7
+    date.setUTCDate(date.getUTCDate() + 4 - (date.getUTCDay() || 7));
+    // Get first day of year
+    const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+    // Calculate full weeks to nearest Thursday
+    const weekNo = Math.ceil(((date.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    // Return the week number
+    return weekNo;
+}

package/ts/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./funcs/getWeekNumber"), exports);
 __exportStar(require("./funcs/Geoip2Paths"), exports);
 __exportStar(require("./funcs/isLocal"), exports);
 __exportStar(require("./funcs/randomString"), exports);
@@ -39,4 +40,7 @@ __exportStar(require("./funcs/getMysql2"), exports);
 __exportStar(require("./funcs/initMysql2Pool"), exports);
 __exportStar(require("./funcs/randomUTFString"), exports);
 __exportStar(require("./funcs/MaxRuntimeHours"), exports);
+// models
+__exportStar(require("./models/Unixtime"), exports);
+__exportStar(require("./models/Timespan"), exports);
 //# sourceMappingURL=index.js.map

package/ts/index.ts

@@ -1,3 +1,4 @@
+export * from "./funcs/getWeekNumber"
 export * from "./funcs/Geoip2Paths";
 export * from "./funcs/isLocal"
 export * from "./funcs/randomString"
@@ -22,4 +23,10 @@ export * from "./funcs/getMysql1"
 export * from "./funcs/getMysql2"
 export * from "./funcs/initMysql2Pool"
 export * from "./funcs/randomUTFString"
-export * from "./funcs/MaxRuntimeHours"
+export * from "./funcs/MaxRuntimeHours"
+
+
+
+// models
+export * from "./models/Unixtime"
+export * from "./models/Timespan"

package/ts/models/Timespan.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timespan = void 0;
+class Timespan {
+    constructor(ms) {
+        this.ms = ms;
+    }
+    get miliseconds() {
+        return this.ms;
+    }
+    get seconds() {
+        return this.ms / 1000;
+    }
+    get minutes() {
+        return this.ms / 1000 / 60;
+    }
+    get hours() {
+        return this.ms / 1000 / 60 / 60;
+    }
+    get days() {
+        return this.ms / 1000 / 60 / 60 / 24;
+    }
+    get weeks() {
+        return this.ms / 1000 / 60 / 60 / 24 / 7;
+    }
+    get months() {
+        return this.ms / 1000 / 60 / 60 / 24 / 30;
+    }
+    static miliseconds(amount) {
+        return new Timespan(amount);
+    }
+    static seconds(amount) {
+        return new Timespan(amount * 1000);
+    }
+    static minutes(mins) {
+        return new Timespan(mins * 60 * 1000);
+    }
+    static hours(hours) {
+        return new Timespan(hours * 60 * 60 * 1000);
+    }
+    static days(days) {
+        return new Timespan(days * 24 * 60 * 60 * 1000);
+    }
+    static weeks(weeks) {
+        return new Timespan(weeks * 7 * 24 * 60 * 60 * 1000);
+    }
+    static months(months) {
+        return new Timespan(months * 30 * 24 * 60 * 60 * 1000);
+    }
+}
+exports.Timespan = Timespan;
+//# sourceMappingURL=Timespan.js.map

package/ts/models/Timespan.ts

@@ -0,0 +1,63 @@
+export class Timespan {
+    constructor(private readonly ms: number){
+    }
+
+    get miliseconds() : number {
+        return this.ms
+    }
+
+    get seconds() : number {
+        return this.ms / 1000
+    }
+
+    get minutes() : number {
+        return this.ms / 1000 / 60
+    }
+
+    get hours() : number {
+        return this.ms / 1000 / 60 / 60
+    }
+
+    get days() : number {
+        return this.ms / 1000 / 60 / 60 / 24
+    }
+
+    get weeks() : number {
+        return this.ms / 1000 / 60 / 60 / 24 / 7
+    }
+
+    get months() : number {
+        return this.ms / 1000 / 60 / 60 / 24 / 30
+    }
+
+    static miliseconds(amount: number): Timespan {
+        return new Timespan(amount)
+    }
+
+    static seconds(amount: number): Timespan {
+        return new Timespan(amount * 1000)
+    }
+
+    static minutes(mins: number): Timespan {
+        return new Timespan(mins * 60 * 1000)
+    }
+
+    static hours(hours: number): Timespan {
+        return new Timespan(hours * 60 * 60 * 1000)
+    }
+
+    static days(days: number): Timespan {
+        return new Timespan(days * 24 * 60 * 60 * 1000)
+    }
+
+    static weeks(weeks: number): Timespan {
+        return new Timespan(weeks * 7 * 24 * 60 * 60 * 1000)
+    }
+
+    static months(months: number): Timespan {
+        return new Timespan(months * 30 * 24 * 60 * 60 * 1000)
+    }
+
+
+    
+}

package/ts/models/Unixtime.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unixtime = void 0;
+const Timespan_1 = require("./Timespan");
+// this will be a class to work with short and long version of unixtime format
+class Unixtime {
+    static NOW() {
+        return new Unixtime(Date.now());
+    }
+    static now() {
+        return new Unixtime(Date.now());
+    }
+    greaterThan(other) {
+        return this.toLongUnixtime() > other.toLongUnixtime();
+    }
+    isEmpty() {
+        return this.toLongUnixtime() == 0;
+    }
+    lessThan(other) {
+        return this.toLongUnixtime() < other.toLongUnixtime();
+    }
+    get elapsed() {
+        return new Timespan_1.Timespan(Date.now() - this.toLongUnixtime());
+    }
+    constructor(value) {
+        if (typeof value === 'string') {
+            this.value = new Date(value);
+        }
+        else if (typeof value === 'number') {
+            // the number might be short or long form(from nodejs Date.now()
+            if (value < 10000000000)
+                value *= 1000;
+            else
+                value = Math.round(value);
+            // set the value
+            this.value = new Date(value);
+        }
+        else {
+            this.value = value;
+        }
+    }
+    addTimespan(timespan) {
+        this.value = new Date(this.value.getTime() + timespan.miliseconds);
+        return this;
+    }
+    subtractTimespan(timespan) {
+        this.value = new Date(this.value.getTime() - timespan.miliseconds);
+        return this;
+    }
+    addMiliseconds(miliseconds = 1) {
+        this.value = new Date(this.value.getTime() + miliseconds);
+        return this;
+    }
+    addSeconds(seconds = 1) {
+        this.value = new Date(this.value.getTime() + seconds * 1000);
+        return this;
+    }
+    addMinutes(minutes = 1) {
+        this.value = new Date(this.value.getTime() + minutes * 60000);
+        return this;
+    }
+    addHours(hours = 1) {
+        this.value = new Date(this.value.getTime() + hours * 3600000);
+        return this;
+    }
+    addDays(days = 1) {
+        this.value = new Date(this.value.getTime() + days * 86400000);
+        return this;
+    }
+    addMonths(months = 1) {
+        this.value.setMonth(this.value.getMonth() + months);
+        return this;
+    }
+    addYears(years = 1) {
+        this.value.setFullYear(this.value.getFullYear() + years);
+        return this;
+    }
+    yyyymmdd() {
+        let mm = this.value.getMonth() + 1;
+        let dd = this.value.getDate();
+        return [this.value.getFullYear(),
+            (mm > 9 ? '' : '0') + mm,
+            (dd > 9 ? '' : '0') + dd
+        ].join('');
+    }
+    yyymmddhh() {
+        let mm = this.value.getMonth() + 1;
+        let dd = this.value.getDate();
+        let hh = this.value.getHours();
+        return [this.value.getFullYear(),
+            (mm > 9 ? '' : '0') + mm,
+            (dd > 9 ? '' : '0') + dd,
+            (hh > 9 ? '' : '0') + hh
+        ].join('');
+    }
+    static from(value) {
+        return new Unixtime(value);
+    }
+    toShortUnixtime() {
+        return Math.round(this.toLongUnixtime() / 1000);
+    }
+    toLongUnixtime() {
+        return this.value.getTime();
+    }
+    toDate() {
+        return this.value;
+    }
+    toISOString() {
+        return this.value.toISOString();
+    }
+    elapsedSeconds() {
+        return Math.round((Date.now() - this.toLongUnixtime()) / 1000);
+    }
+    elapsedMinutes() {
+        return Math.round(this.elapsedSeconds() / 60);
+    }
+}
+exports.Unixtime = Unixtime;
+Unixtime.EMPTY = new Unixtime(new Date(0));
+//# sourceMappingURL=Unixtime.js.map

package/ts/models/Unixtime.test.ts

@@ -0,0 +1,98 @@
+import { Unixtime } from './Unixtime';
+
+describe('Unixtime', () => {
+  it('should create Unixtime object from Date', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    expect(unixtime.toDate()).toEqual(date);
+  });
+
+  it('should create Unixtime object from string', () => {
+    const dateString = '2022-01-01T00:00:00Z';
+    const date = new Date(dateString);
+    const unixtime = new Unixtime(dateString);
+    expect(unixtime.toDate()).toEqual(date);
+  });
+
+  it('should create Unixtime object from number (short form)', () => {
+    const timestamp = 1640995200; // January 1, 2022 00:00:00 UTC
+    const date = new Date(timestamp * 1000);
+    const unixtime = new Unixtime(timestamp);
+    expect(unixtime.toDate()).toEqual(date);
+  });
+
+  it('should create Unixtime object from number (long form)', () => {
+    const timestamp = 1640995200000; // January 1, 2022 00:00:00 UTC
+    const date = new Date(timestamp);
+    const unixtime = new Unixtime(timestamp);
+    expect(unixtime.toDate()).toEqual(date);
+  });
+
+  it('should convert Unixtime to short Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const shortUnixtime = Math.round(date.getTime() / 1000);
+    expect(unixtime.toShortUnixtime()).toEqual(shortUnixtime);
+  });
+
+  it('should convert Unixtime to long Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    expect(unixtime.toLongUnixtime()).toEqual(date.getTime());
+  });
+
+  it('should convert Unixtime to ISO string', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    expect(unixtime.toISOString()).toEqual(date.toISOString());
+  });
+
+  it('should add miliseconds to Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const addedUnixtime = unixtime.addMiliseconds(1000);
+    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 1000));
+  });
+
+  it('should add seconds to Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const addedUnixtime = unixtime.addSeconds(1);
+    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 1000));
+  });
+
+  it('should add minutes to Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const addedUnixtime = unixtime.addMinutes(1);
+    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 60000));
+  });
+
+  it('should add hours to Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const addedUnixtime = unixtime.addHours(1);
+    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 3600000));
+  });
+
+  it('should add days to Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const addedUnixtime = unixtime.addDays(1);
+    expect(addedUnixtime.toDate()).toEqual(new Date(date.getTime() + 86400000));
+  });
+
+  it('should add months to Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const addedUnixtime = unixtime.addMonths(1);
+    expect(addedUnixtime.toDate()).toEqual(new Date(date.setMonth(date.getMonth() + 1)));
+  });
+
+  it('should add years to Unixtime', () => {
+    const date = new Date();
+    const unixtime = new Unixtime(date);
+    const addedUnixtime = unixtime.addYears(1);
+    expect(addedUnixtime.toDate()).toEqual(new Date(date.setFullYear(date.getFullYear() + 1)));
+  });
+});

package/ts/models/Unixtime.ts

@@ -0,0 +1,144 @@
+import { Timespan } from "./Timespan"
+
+// this will be a class to work with short and long version of unixtime format
+export class Unixtime {
+    private value: Date
+
+
+    static EMPTY = new Unixtime(new Date(0))
+
+    static NOW() {
+        return new Unixtime(Date.now())
+    }
+
+    static now() {
+        return new Unixtime(Date.now())
+    }
+
+    greaterThan(other: Unixtime) {
+        return this.toLongUnixtime() > other.toLongUnixtime()
+    }
+
+    isEmpty() {
+        return this.toLongUnixtime() == 0
+    }
+
+    lessThan(other: Unixtime) {
+        return this.toLongUnixtime() < other.toLongUnixtime()
+    }
+
+    get elapsed():Timespan {
+        return new Timespan(Date.now() - this.toLongUnixtime())
+    }
+
+
+    constructor(value: Date | string | number) {
+        if (typeof value === 'string') {
+            this.value = new Date(value)
+        } else if (typeof value === 'number') {
+            // the number might be short or long form(from nodejs Date.now()
+            if (value < 10000000000) value *= 1000
+            else
+                value = Math.round(value)
+            // set the value
+            this.value = new Date(value)
+        } else {
+            this.value = value
+        }
+    }
+
+    public addTimespan(timespan: Timespan): Unixtime {
+        this.value = new Date(this.value.getTime() + timespan.miliseconds)
+        return this
+    }
+
+    public subtractTimespan(timespan: Timespan): Unixtime {
+        this.value = new Date(this.value.getTime() - timespan.miliseconds)
+        return this
+    }
+
+    public addMiliseconds(miliseconds: number = 1): Unixtime {
+        this.value = new Date(this.value.getTime() + miliseconds)
+        return this
+    }
+
+    public addSeconds(seconds: number = 1): Unixtime {
+        this.value = new Date(this.value.getTime() + seconds * 1000)
+        return this
+    }
+
+    public addMinutes(minutes: number = 1): Unixtime {
+        this.value = new Date(this.value.getTime() + minutes * 60000)
+        return this
+    }
+
+    public addHours(hours: number = 1): Unixtime {
+        this.value = new Date(this.value.getTime() + hours * 3600000)
+        return this
+    }
+
+    public addDays(days: number = 1): Unixtime {
+        this.value = new Date(this.value.getTime() + days * 86400000)
+        return this
+    }
+
+    public addMonths(months: number = 1): Unixtime {
+        this.value.setMonth(this.value.getMonth() + months)
+        return this
+    }
+
+    public addYears(years: number = 1): Unixtime {
+        this.value.setFullYear(this.value.getFullYear() + years)
+        return this
+    }
+
+    public yyyymmdd(): string {
+        let mm = this.value.getMonth() + 1
+        let dd = this.value.getDate()
+        return [this.value.getFullYear(),
+        (mm > 9 ? '' : '0') + mm,
+        (dd > 9 ? '' : '0') + dd
+        ].join('')
+    }
+
+    public yyymmddhh(): string {
+        let mm = this.value.getMonth() + 1
+        let dd = this.value.getDate()
+        let hh = this.value.getHours()
+        return [this.value.getFullYear(),
+        (mm > 9 ? '' : '0') + mm,
+        (dd > 9 ? '' : '0') + dd,
+        (hh > 9 ? '' : '0') + hh
+        ].join('')
+    }
+
+
+    static from(value: Date | string | number) {
+        return new Unixtime(value)
+    }
+
+    public toShortUnixtime(): number {
+        return Math.round(this.toLongUnixtime() / 1000)
+    }
+
+    public toLongUnixtime(): number {
+        return this.value.getTime()
+    }
+
+    public toDate(): Date {
+        return this.value
+    }
+
+    public toISOString(): string {
+        return this.value.toISOString()
+    }
+
+    public elapsedSeconds(): number {
+        return Math.round((Date.now() - this.toLongUnixtime()) / 1000)
+    }
+
+    public elapsedMinutes(): number {
+        return Math.round(this.elapsedSeconds() / 60)
+    }
+
+}