feat: rewrite project with typescript, use jest and rollup for bundling

BREAKING CHANGE: module format has been changed. Please ensure your
environment or bundler continue to import the module correctly after
version change

Author: amoshydra

.npmignore

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

jest.config.js

@@ -26,40 +26,25 @@
   },
   "scripts": {
     "build": "rollup --config",
-    "test": "yarn run test:coverage",
-    "test:coverage": "nyc --reporter=lcovonly ava",
-    "test:unit": "ava"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
+  "browser": "dist/index.umd.js",
+  "typings": "dist/index.d.ts",
   "files": [
-    "dist",
-    "types/*.d.ts"
+    "dist"
   ],
   "dependencies": {},
   "devDependencies": {
-    "@babel/core": "^7.1.2",
-    "@babel/preset-env": "^7.1.0",
-    "ava": "^1.0.0-rc.1",
-    "codecov": "^3.7.1",
-    "eslint": "^5.8.0",
-    "esm": "^3.0.84",
-    "live-server": "^1.2.0",
-    "nyc": "^13.1.0",
-    "rollup": "^0.66.6",
-    "rollup-plugin-babel": "^4.0.3",
-    "rollup-plugin-babel-minify": "^6.1.1",
-    "rollup-plugin-commonjs": "^9.2.0",
-    "rollup-plugin-node-resolve": "^3.4.0"
-  },
-  "typings": "types/index.d.ts",
-  "ava": {
-    "require": [
-      "esm"
-    ],
-    "files": [
-      "test/**/*.spec.js"
-    ],
-    "verbose": true
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/jest": "^29.5.12",
+    "eslint": "^9.0.0",
+    "jest": "^29.7.0",
+    "rollup": "^4.14.1",
+    "ts-jest": "^29.1.2",
+    "tslib": "^2.6.2",
+    "typescript": "^5.4.4"
   }
 }

package.json

@@ -0,0 +1,44 @@
+// @ts-check
+import typescript from '@rollup/plugin-typescript';
+import pkg from './package.json' assert { type: "json" };
+
+/**
+ * @type { import("rollup").OutputOptions }
+ */
+const commonOutput = {
+  sourcemap: true,
+  interop: "defaultOnly",
+}
+
+/**
+ * @type { import("rollup").RollupOptions }
+ */
+const config = {
+  input: 'src/index.ts',
+  output: [
+    {
+      ...commonOutput,
+      file: pkg.module,
+      format: 'esm',
+    },
+    {
+      ...commonOutput,
+      file: pkg.main,
+      format: 'cjs',
+    },
+    {
+      ...commonOutput,
+      file: pkg.browser,
+      format: 'umd',
+      name: 'timeMaker',
+    },
+  ],
+  plugins: [
+    typescript({
+      tsconfig: "tsconfig.build.json",
+      sourceMap: false,
+    }),
+  ],
+};
+
+export default config;

rollup.config.js

@@ -0,0 +1,113 @@
+// @ts-check
+import T from './index';
+
+const ZERO = 0;
+
+// Usage testing
+it('should output correct value with its static method', () => {
+  expect(ZERO).toBe( T.milliseconds(1) - (1));
+  expect(ZERO).toBe(      T.seconds(1) - (1000));
+  expect(ZERO).toBe(      T.minutes(1) - (60 * 1000));
+  expect(ZERO).toBe(        T.hours(1) - (60 * 60 * 1000));
+  expect(ZERO).toBe(         T.days(1) - (24 * 60 * 60 * 1000));
+  expect(ZERO).toBe(        T.weeks(1) - (7 * 24 * 60 * 60 * 1000));
+});
+
+it('should output 0 when 0 given as param', () => {
+  expect(ZERO).toBe( T.milliseconds(0) - ZERO);
+  expect(ZERO).toBe(      T.seconds(0) - ZERO);
+  expect(ZERO).toBe(      T.minutes(0) - ZERO);
+  expect(ZERO).toBe(        T.hours(0) - ZERO);
+  expect(ZERO).toBe(         T.days(0) - ZERO);
+  expect(ZERO).toBe(        T.weeks(0) - ZERO);
+});
+
+it('should output 0 when nothing given as param', () => {
+  expect(ZERO).toBe( T.milliseconds() - ZERO);
+  expect(ZERO).toBe(      T.seconds() - ZERO);
+  expect(ZERO).toBe(      T.minutes() - ZERO);
+  expect(ZERO).toBe(        T.hours() - ZERO);
+  expect(ZERO).toBe(         T.days() - ZERO);
+  expect(ZERO).toBe(        T.weeks() - ZERO);
+
+  expect(ZERO).toBe( T.milliseconds(undefined) - ZERO);
+  expect(ZERO).toBe(      T.seconds(undefined) - ZERO);
+  expect(ZERO).toBe(      T.minutes(undefined) - ZERO);
+  expect(ZERO).toBe(        T.hours(undefined) - ZERO);
+  expect(ZERO).toBe(         T.days(undefined) - ZERO);
+  expect(ZERO).toBe(        T.weeks(undefined) - ZERO);
+
+  expect(ZERO).toBe( T.milliseconds(null) - ZERO);
+  expect(ZERO).toBe(      T.seconds(null) - ZERO);
+  expect(ZERO).toBe(      T.minutes(null) - ZERO);
+  expect(ZERO).toBe(        T.hours(null) - ZERO);
+  expect(ZERO).toBe(         T.days(null) - ZERO);
+  expect(ZERO).toBe(        T.weeks(null) - ZERO);
+});
+
+it('should work with chaining', () => {
+  const OF_8_DAYS = (8 * (24 * 60 * 60 * 1000));
+
+  expect(ZERO).toBe( T.weeks(1).days(1) - OF_8_DAYS);
+});
+
+it('should allow 0 or nothing during chaining', () => {
+  const OF_8_DAYS = (8 * (24 * 60 * 60 * 1000));
+
+  expect(ZERO).toBe( T.weeks(1).days(0        ).days(1) - OF_8_DAYS);
+  expect(ZERO).toBe( T.weeks(1).days(         ).days(1) - OF_8_DAYS);
+  expect(ZERO).toBe( T.weeks(1).days(null     ).days(1) - OF_8_DAYS);
+  expect(ZERO).toBe( T.weeks(1).days(undefined).days(1) - OF_8_DAYS);
+});
+
+// Implementation Assertions
+it('static methods should produce instance of T', () => {
+  expect(T.milliseconds(1)).toBeInstanceOf(T);
+  expect(T.seconds(1)).toBeInstanceOf(T);
+  expect(T.minutes(1)).toBeInstanceOf(T);
+  expect(T.hours(1)).toBeInstanceOf(T);
+  expect(T.days(1)).toBeInstanceOf(T);
+  expect(T.weeks(1)).toBeInstanceOf(T);
+});
+
+// Implementation Assertions
+it('instance methods should produce instance of T', () => {
+  // The following produce type error
+  // but should still be allowed in non-typescript environment
+
+  // @ts-ignore
+  expect(new T().milliseconds(1)).toBeInstanceOf(T);
+  // @ts-ignore
+  expect(new T().seconds(1)).toBeInstanceOf(T);
+  // @ts-ignore
+  expect(new T().minutes(1)).toBeInstanceOf(T);
+  // @ts-ignore
+  expect(new T().hours(1)).toBeInstanceOf(T);
+  // @ts-ignore
+  expect(new T().days(1)).toBeInstanceOf(T);
+  // @ts-ignore
+  expect(new T().weeks(1)).toBeInstanceOf(T);
+});
+
+// Type coercion
+it('stringification should produce number string', () => {
+  expect(
+    JSON.stringify({
+      time: T.seconds(0),
+    })
+  ).toBe(
+    JSON.stringify({
+      time: 0,
+    })
+  );
+
+  expect(
+    JSON.stringify({
+      time: T.seconds(0),
+    })
+  ).not.toBe(
+    JSON.stringify({
+      time: '0',
+    })
+  );
+});

rollup.config.mjs

@@ -0,0 +1,53 @@
+type T = number | Number | Time | null | undefined;
+type N = number;
+
+type TimeReturn = Time & number;
+
+class Time extends Number {
+  public value = 0;
+
+  constructor(ms?: T) {
+    super(ms);
+    this.value = +(ms as number) || 0;
+  }
+
+  valueOf() {
+    return this.value as number;
+  }
+
+  // Static methods
+  static milliseconds(ms?: T) { return new Time(ms) as TimeReturn; }
+  static seconds(s?: T) { return Time.milliseconds(s as N * 1000) as TimeReturn; }
+  static minutes(m?: T) { return Time.seconds(m as N * 60) as TimeReturn; }
+  static hours(h?: T) { return Time.minutes(h as N * 60) as TimeReturn; }
+  static days(d?: T) { return Time.hours(d as N * 24) as TimeReturn; }
+  static weeks(w?: T) { return Time.days(w as N * 7) as TimeReturn; }
+
+  // Instance methods
+  milliseconds(ms?: T) {
+    this.value += Time.milliseconds(ms).value;
+    return this as unknown as TimeReturn;
+  }
+  seconds(s?: T) {
+    this.value += Time.seconds(s).value;
+    return this as unknown as TimeReturn;
+  }
+  minutes(m?: T) {
+    this.value += Time.minutes(m).value;
+    return this as unknown as TimeReturn;
+  }
+  hours(h?: T) {
+    this.value += Time.hours(h).value;
+    return this as unknown as TimeReturn;
+  }
+  days(d?: T) {
+    this.value += Time.days(d).value;
+    return this as unknown as TimeReturn;
+  }
+  weeks(w?: T) {
+    this.value += Time.weeks(w).value;
+    return this as unknown as TimeReturn;
+  }
+}
+
+export default Time as unknown as TimeReturn;