mybase 1.1.34 → 1.1.35

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.d.ts

@@ -0,0 +1,32 @@
+import { Timespan } from "./Timespan";
+export declare class Unixtime {
+    private value;
+    static EMPTY: Unixtime;
+    static NOW(): Unixtime;
+    static now(): Unixtime;
+    greaterThan(other: Unixtime): boolean;
+    isEmpty(): boolean;
+    lessThan(other: Unixtime): boolean;
+    get elapsed(): Timespan;
+    constructor(value: Date | string | number);
+    addTimespan(timespan: Timespan): Unixtime;
+    subtractTimespan(timespan: Timespan): Unixtime;
+    addMiliseconds(miliseconds?: number): Unixtime;
+    addSeconds(seconds?: number): Unixtime;
+    addMinutes(minutes?: number): Unixtime;
+    addHours(hours?: number): Unixtime;
+    addDays(days?: number): Unixtime;
+    addMonths(months?: number): Unixtime;
+    addYears(years?: number): Unixtime;
+    yyyymmdd(): string;
+    yyymmddhh(): string;
+    getDay(): number;
+    static from(value: Date | string | number): Unixtime;
+    toShortUnixtime(): number;
+    toLongUnixtime(): number;
+    toDate(): Date;
+    toISOString(): string;
+    elapsedSeconds(): number;
+    elapsedMinutes(): number;
+    static try(value: Date | string | number): Unixtime | null;
+}

package/ts/models/Unixtime.js

@@ -0,0 +1,137 @@
+"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 if (value instanceof Date) {
+            this.value = value;
+        }
+        else {
+            throw new Error('Invalid value');
+        }
+        if (isNaN(this.value.getTime())) {
+            throw new Error('Invalid date');
+        }
+    }
+    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('');
+    }
+    getDay() {
+        return this.value.getDay();
+    }
+    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);
+    }
+    static try(value) {
+        try {
+            return new Unixtime(value);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+exports.Unixtime = Unixtime;
+Unixtime.EMPTY = new Unixtime(new Date(0));
+//# sourceMappingURL=Unixtime.js.map

package/ts/models/Unixtime.test.ts

@@ -0,0 +1,102 @@
+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('create invalid date should throw error', () => {
+    expect(() => new Unixtime('invalid date')).toThrow();
+  })
+
+  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,164 @@
+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 if (value instanceof Date) {
+            this.value = value
+        } 
+        else {
+            throw new Error('Invalid value')
+        }
+
+        if (isNaN(this.value.getTime())) {
+            throw new Error('Invalid date')
+        }
+    }
+
+    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('')
+    }
+
+
+    public getDay() : number {
+        return this.value.getDay()
+    }
+
+    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)
+    }
+
+
+    static try(value: Date | string | number): Unixtime | null {
+        try {
+            return new Unixtime(value)
+        } catch (e) {
+            return null
+        }
+    }
+}

package/ts/types.d.ts

@@ -0,0 +1 @@
+export type UnixtimeShort = number;

package/ts/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/ts/types.ts

@@ -0,0 +1 @@
+export type UnixtimeShort = number

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {        
+    "target": "es2017",          
+    "experimentalDecorators": true,                   
+    "emitDecoratorMetadata": true,                    
+    "module": "commonjs",        
+    "moduleResolution" : "Node",
+    "esModuleInterop": true,                  
+    "forceConsistentCasingInFileNames": true,            
+    "strict": true,
+    "declaration": true, // Generates corresponding .d.ts file
+    "noImplicitReturns": true, // Report error when not all code paths in function return a value
+    "noUnusedLocals": true, // Report errors on unused locals
+    // "noUnusedParameters": true, // Report errors on unused parameters
+    "noFallthroughCasesInSwitch": true, // Report errors for fallthrough cases in switch statement
+    // "noUncheckedIndexedAccess": true, // Include 'undefined' in index signature results
+    "noImplicitAny": true, // Raise error on expressions and declarations with an implied 'any' type
+    "strictNullChecks": true, // Enable strict null checking
+    "strictFunctionTypes": true, // Ensure function parameter types match
+    "strictBindCallApply": true, // Ensure 'bind', 'call', and 'apply' methods match function types
+    "strictPropertyInitialization": true, // Ensure non-undefined class properties are initialized in the constructor
+    "alwaysStrict": true, // Parse in strict mode and emit "use strict" for each source file
+    "sourceMap": true,
+    "skipLibCheck": true,      
+    "baseUrl": ".",
+    "paths": {
+      "@root/*": ["./*"],
+      "@models/*": ["./models/*"],
+      "@inc/*": ["./inc/ts/*"]
+    },
+    "typeRoots": ["./node_modules/@types", "./types/"]
+  },
+  "exclude": [
+    "**/*.test.ts"
+  ]
+}