@choksheak/ts-utils 0.3.0 → 0.3.1

package/localStore.mjs

@@ -0,0 +1,235 @@
+// src/timeConstants.ts
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = 6e4;
+var MS_PER_HOUR = 36e5;
+var MS_PER_DAY = 864e5;
+
+// src/duration.ts
+function durationToMs(duration) {
+  const daysMs = (duration.days ?? 0) * MS_PER_DAY;
+  const hoursMs = (duration.hours ?? 0) * MS_PER_HOUR;
+  const minsMs = (duration.minutes ?? 0) * MS_PER_MINUTE;
+  const secsMs = (duration.seconds ?? 0) * MS_PER_SECOND;
+  const msMs = duration.milliseconds ?? 0;
+  return daysMs + hoursMs + minsMs + secsMs + msMs;
+}
+function durationOrMsToMs(duration) {
+  return typeof duration === "number" ? duration : durationToMs(duration);
+}
+
+// src/localStore.ts
+var LocalStoreConfig = {
+  /** All items with the same store name will share the same storage space. */
+  storeName: "ts-utils",
+  /** 30 days in ms. */
+  expiryMs: MS_PER_DAY * 30,
+  /** Do GC once per day. */
+  gcIntervalMs: MS_PER_DAY
+};
+function configureLocalStore(config) {
+  Object.assign(LocalStoreConfig, config);
+}
+function validateStoredObject(obj) {
+  if (!obj || typeof obj !== "object" || obj.value === void 0 || typeof obj.storedMs !== "number" || typeof obj.expiryMs !== "number" || Date.now() >= obj.expiryMs) {
+    return void 0;
+  }
+  return obj;
+}
+var LocalStore = class {
+  constructor(storeName, options) {
+    this.storeName = storeName;
+    this.keyPrefix = storeName + ":";
+    this.defaultExpiryMs = options?.defaultExpiryMs ? durationOrMsToMs(options.defaultExpiryMs) : LocalStoreConfig.expiryMs;
+    this.gcIntervalMs = options?.gcIntervalMs ? durationOrMsToMs(options.gcIntervalMs) : LocalStoreConfig.gcIntervalMs;
+    this.gcMsStorageKey = `__localStore:lastGcMs:${storeName}`;
+  }
+  /**
+   * The prefix string for the local storage key which identifies items
+   * belonging to this namespace.
+   */
+  keyPrefix;
+  /** Local storage key name for the last GC completed timestamp. */
+  gcMsStorageKey;
+  defaultExpiryMs;
+  gcIntervalMs;
+  /** Set a value in the store. */
+  set(key, value, expiryDeltaMs = this.defaultExpiryMs) {
+    const nowMs = Date.now();
+    const obj = {
+      value,
+      storedMs: nowMs,
+      expiryMs: nowMs + durationOrMsToMs(expiryDeltaMs)
+    };
+    localStorage.setItem(this.keyPrefix + key, JSON.stringify(obj));
+    this.gc();
+    return value;
+  }
+  /** Delete one or multiple keys. */
+  delete(key) {
+    if (typeof key === "string") {
+      localStorage.removeItem(this.keyPrefix + key);
+    } else {
+      for (const k of key) {
+        localStorage.removeItem(this.keyPrefix + k);
+      }
+    }
+  }
+  /** Mainly used to get the expiration timestamp of an object. */
+  getStoredObject(key) {
+    const k = this.keyPrefix + key;
+    const stored = localStorage.getItem(k);
+    if (!stored) {
+      return void 0;
+    }
+    try {
+      const parsed = JSON.parse(stored);
+      const obj = validateStoredObject(parsed);
+      if (!obj) {
+        this.delete(k);
+        this.gc();
+        return void 0;
+      }
+      return obj;
+    } catch (e) {
+      console.error(`Invalid local value: ${k}=${stored}:`, e);
+      this.delete(k);
+      this.gc();
+      return void 0;
+    }
+  }
+  /** Get a value by key, or undefined if it does not exist. */
+  get(key) {
+    const obj = this.getStoredObject(key);
+    return obj?.value;
+  }
+  /** Generic way to iterate through all entries. */
+  forEach(callback) {
+    for (const k of Object.keys(localStorage)) {
+      if (!k.startsWith(this.keyPrefix)) continue;
+      const key = k.slice(this.keyPrefix.length);
+      const obj = this.getStoredObject(key);
+      if (!obj) continue;
+      callback(key, obj.value, obj.expiryMs, obj.storedMs);
+    }
+  }
+  /**
+   * Returns the number of items in the store. Note that getting the size
+   * requires iterating through the entire store because the items could expire
+   * at any time, and hence the size is a dynamic number.
+   */
+  size() {
+    let count = 0;
+    this.forEach(() => {
+      count++;
+    });
+    return count;
+  }
+  /** Remove all items from the store. */
+  clear() {
+    for (const key of Object.keys(localStorage)) {
+      if (key.startsWith(this.keyPrefix)) {
+        localStorage.removeItem(key);
+      }
+    }
+  }
+  /**
+   * Returns all items as map of key to value, mainly used for debugging dumps.
+   * The type T is applied to all values, even though they might not be of type
+   * T (in the case when you store different data types in the same store).
+   */
+  asMap() {
+    const map = /* @__PURE__ */ new Map();
+    this.forEach((key, value, expiryMs, storedMs) => {
+      map.set(key, { value, expiryMs, storedMs });
+    });
+    return map;
+  }
+  /** Returns the ms timestamp for the last GC (garbage collection). */
+  get lastGcMs() {
+    const lastGcMsStr = globalThis.localStorage.getItem(this.gcMsStorageKey);
+    if (!lastGcMsStr) return 0;
+    const ms = Number(lastGcMsStr);
+    return isNaN(ms) ? 0 : ms;
+  }
+  /** Set the ms timestamp for the last GC (garbage collection). */
+  set lastGcMs(ms) {
+    globalThis.localStorage.setItem(this.gcMsStorageKey, String(ms));
+  }
+  /** Perform garbage-collection if due, else do nothing. */
+  gc() {
+    const lastGcMs = this.lastGcMs;
+    if (!lastGcMs) {
+      this.lastGcMs = Date.now();
+      return;
+    }
+    if (Date.now() < lastGcMs + this.gcIntervalMs) {
+      return;
+    }
+    this.gcNow();
+  }
+  /**
+   * Perform garbage collection immediately without checking whether we are
+   * due for the next GC or not.
+   */
+  gcNow() {
+    console.log(`Starting localStore GC on ${this.storeName}`);
+    this.lastGcMs = Date.now();
+    let count = 0;
+    this.forEach((key, value, expiryMs) => {
+      if (Date.now() >= expiryMs) {
+        this.delete(key);
+        count++;
+      }
+    });
+    console.log(
+      `Finished localStore GC on ${this.storeName} - deleted ${count} keys`
+    );
+    this.lastGcMs = Date.now();
+  }
+  /** Returns `this` casted into a StorageAdapter<T>. */
+  asStorageAdapter() {
+    return this;
+  }
+};
+var localStore = new LocalStore(LocalStoreConfig.storeName);
+var LocalStoreItem = class {
+  constructor(key, defaultExpiryMs = LocalStoreConfig.expiryMs, store = localStore) {
+    this.key = key;
+    this.store = store;
+    this.defaultExpiryMs = defaultExpiryMs && durationOrMsToMs(defaultExpiryMs);
+  }
+  defaultExpiryMs;
+  /** Set a value in the store. */
+  set(value, expiryDeltaMs = this.defaultExpiryMs) {
+    this.store.set(this.key, value, expiryDeltaMs);
+  }
+  /**
+   * Example usage:
+   *
+   *   const { value, storedMs, expiryMs, storedMs } =
+   *     await myLocalItem.getStoredObject();
+   */
+  getStoredObject() {
+    return this.store.getStoredObject(this.key);
+  }
+  /** Get a value by key, or undefined if it does not exist. */
+  get() {
+    return this.store.get(this.key);
+  }
+  /** Delete this key from the store. */
+  delete() {
+    this.store.delete(this.key);
+  }
+};
+function localStoreItem(key, expiryMs, store = localStore) {
+  expiryMs = expiryMs && durationOrMsToMs(expiryMs);
+  return new LocalStoreItem(key, expiryMs, store);
+}
+export {
+  LocalStore,
+  LocalStoreConfig,
+  LocalStoreItem,
+  configureLocalStore,
+  localStore,
+  localStoreItem
+};

package/logging.d.ts

@@ -1,2 +1,4 @@
-export declare function stringify(u: unknown): string;
-export declare function capLength(u: unknown, maxLength?: number): string;
+declare function stringify(u: unknown): string;
+declare function capLength(u: unknown, maxLength?: number): string;
+
+export { capLength, stringify };

package/nonEmpty.d.ts

@@ -5,4 +5,6 @@
  * @param varName The variable name to include in the error to throw when t is
  *   empty. Defaults to 'value'.
  */
-export declare function nonEmpty<T>(t: T | null | undefined | "" | 0 | -0 | 0n | false | typeof NaN, varName?: string): T;
+declare function nonEmpty<T>(t: T | null | undefined | "" | 0 | -0 | 0n | false | typeof NaN, varName?: string): T;
+
+export { nonEmpty };

package/nonNil.d.ts

@@ -5,4 +5,6 @@
  * @param varName The variable name to include in the error to throw when t is
  *   nil. Defaults to 'value'.
  */
-export declare function nonNil<T>(t: T | null | undefined, varName?: string): T;
+declare function nonNil<T>(t: T | null | undefined, varName?: string): T;
+
+export { nonNil };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@choksheak/ts-utils",
   "license": "The Unlicense",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Random Typescript utilities with support for full tree-shaking",
   "private": false,
   "scripts": {
     "lint": "eslint .",
     "fix": "eslint . --fix",
-    "tsc": "npx tsc --noEmit --allowSyntheticDefaultImports",
+    "tsc": "npx tsc",
     "ft": "npm run fix && npm run tsc",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -34,11 +34,11 @@
   "lint-staged": {
     "*.{ts,tsx,js,jsx}": [
       "echo Using `eslint --fix` will revert changes without printing errors!",
-      "eslint ."
+      "npm run lint"
     ],
     "*.{ts,tsx}": [
       "echo `tsc-files --noEmit` cannot read *.module.css files",
-      "npm run tsc"
+      "bash -c 'npx tsc'"
     ]
   },
   "repository": {
@@ -70,9 +70,10 @@
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "fake-indexeddb": "^6.0.0",
     "globals": "^16.4.0",
+    "jest-environment-jsdom": "^29.7.0",
     "jiti": "^2.6.1",
     "lint-staged": "^16.2.6",
-    "jest-environment-jsdom": "^29.7.0",
+    "mock-local-storage": "^1.1.24",
     "prettier": "^3.6.2",
     "simple-git-hooks": "^2.13.1",
     "tsup": "^8.5.0",
@@ -175,6 +176,19 @@
         "default": "./isEmpty.cjs"
       }
     },
+    "./iterators": {
+      "types": "./iterators.d.ts",
+      "import": {
+        "production": "./iterators.min.mjs",
+        "development": "./iterators.mjs",
+        "default": "./iterators.mjs"
+      },
+      "require": {
+        "production": "./iterators.min.cjs",
+        "development": "./iterators.cjs",
+        "default": "./iterators.cjs"
+      }
+    },
     "./kvStore": {
       "types": "./kvStore.d.ts",
       "import": {
@@ -188,17 +202,17 @@
         "default": "./kvStore.cjs"
       }
     },
-    "./localStorageCache": {
-      "types": "./localStorageCache.d.ts",
+    "./localStore": {
+      "types": "./localStore.d.ts",
       "import": {
-        "production": "./localStorageCache.min.mjs",
-        "development": "./localStorageCache.mjs",
-        "default": "./localStorageCache.mjs"
+        "production": "./localStore.min.mjs",
+        "development": "./localStore.mjs",
+        "default": "./localStore.mjs"
       },
       "require": {
-        "production": "./localStorageCache.min.cjs",
-        "development": "./localStorageCache.cjs",
-        "default": "./localStorageCache.cjs"
+        "production": "./localStore.min.cjs",
+        "development": "./localStore.cjs",
+        "default": "./localStore.cjs"
       }
     },
     "./logging": {
@@ -318,6 +332,19 @@
         "default": "./sleep.cjs"
       }
     },
+    "./storageAdapter": {
+      "types": "./storageAdapter.d.ts",
+      "import": {
+        "production": "./storageAdapter.min.mjs",
+        "development": "./storageAdapter.mjs",
+        "default": "./storageAdapter.mjs"
+      },
+      "require": {
+        "production": "./storageAdapter.min.cjs",
+        "development": "./storageAdapter.cjs",
+        "default": "./storageAdapter.cjs"
+      }
+    },
     "./sum": {
       "types": "./sum.d.ts",
       "import": {
@@ -381,11 +408,14 @@
       "isEmpty": [
         "./isEmpty.d.ts"
       ],
+      "iterators": [
+        "./iterators.d.ts"
+      ],
       "kvStore": [
         "./kvStore.d.ts"
       ],
-      "localStorageCache": [
-        "./localStorageCache.d.ts"
+      "localStore": [
+        "./localStore.d.ts"
       ],
       "logging": [
         "./logging.d.ts"
@@ -414,6 +444,9 @@
       "sleep": [
         "./sleep.d.ts"
       ],
+      "storageAdapter": [
+        "./storageAdapter.d.ts"
+      ],
       "sum": [
         "./sum.d.ts"
       ],

package/round.d.ts

@@ -4,9 +4,11 @@
  * at the end. To show the exact number of decimal places, you'll need to use
  * toFixed(). E.g. round(1.20, 2).toFixed(2).
  */
-export declare function round(n: number, numDecimalPlaces?: number): number;
+declare function round(n: number, numDecimalPlaces?: number): number;
 /**
  * Returns a string with the number in the exact number of decimal places
  * specified, in case the number ends with zeroes.
  */
-export declare function roundS(n: number, numDecimalPlaces?: number): string;
+declare function roundS(n: number, numDecimalPlaces?: number): string;
+
+export { round, roundS };

package/safeBtoa.d.ts

@@ -1,4 +1,6 @@
 /**
  * Base 64 encode the given input string, but safely.
  */
-export declare function safeBtoa(input: string): string;
+declare function safeBtoa(input: string): string;
+
+export { safeBtoa };

package/safeParseFloat.d.ts

@@ -1,4 +1,6 @@
 /**
  * Returns 0 or the given defaultValue if the string is not a valid number.
  */
-export declare function safeParseFloat<T>(s: string, defaultValue?: T | number): T | number;
+declare function safeParseFloat<T>(s: string, defaultValue?: T | number): T | number;
+
+export { safeParseFloat };

package/safeParseInt.d.ts

@@ -1,4 +1,6 @@
 /**
  * Returns 0 or the given defaultValue if the string is not a valid number.
  */
-export declare function safeParseInt<T>(s: string, defaultValue?: T | number): T | number;
+declare function safeParseInt<T>(s: string, defaultValue?: T | number): T | number;
+
+export { safeParseInt };

package/sha256.d.ts

@@ -1,4 +1,6 @@
 /**
  * SHA-256 hash an input string into an ArrayBuffer.
  */
-export declare function sha256(input: string): Promise<ArrayBuffer>;
+declare function sha256(input: string): Promise<ArrayBuffer>;
+
+export { sha256 };

package/sleep.d.ts

@@ -2,4 +2,6 @@
  * Sleep for a given number of milliseconds. Note that this method is async,
  * so please remember to call it with await, like `await sleep(1000);`.
  */
-export declare function sleep(ms: number): Promise<void>;
+declare function sleep(ms: number): Promise<void>;
+
+export { sleep };

package/storageAdapter.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storageAdapter.ts
+var storageAdapter_exports = {};
+module.exports = __toCommonJS(storageAdapter_exports);

package/storageAdapter.d.mts

@@ -0,0 +1,33 @@
+import { Duration } from './duration.mjs';
+
+/**
+ * Most basic interface for a storage implementation. This is designed to be
+ * quite easily implemented by users to plug in any new underlying storage.
+ */
+type StorageAdapter<T> = {
+    set: (key: string, value: T) => Promise<void> | void;
+    get: (key: string) => Promise<T | undefined> | T | undefined;
+    delete: (key: string) => Promise<void> | void;
+    clear: () => Promise<void> | void;
+};
+/** Most basic interface for stored object. */
+type StoredObject<T> = {
+    value: T;
+    storedMs: number;
+    expiryMs: number;
+};
+/**
+ * Full interface for a storage implementation. Each method can be either sync
+ * or async, and the interface works with either implementation scheme.
+ */
+type FullStorageAdapter<T> = StorageAdapter<T> & {
+    set: (key: string, value: T, expiryDeltaMs?: number | Duration) => Promise<void> | void;
+    getStoredObject: (key: string) => Promise<StoredObject<T> | undefined> | StoredObject<T> | undefined;
+    forEach(callback: (key: string, value: T, expiryMs: number, storedMs: number) => void | Promise<void>): Promise<void> | void;
+    size(): Promise<number> | number;
+    asMap<T>(): Promise<Map<string, StoredObject<T>>> | Map<string, StoredObject<T>>;
+    gc: () => Promise<void> | void;
+    gcNow: () => Promise<void> | void;
+};
+
+export type { FullStorageAdapter, StorageAdapter, StoredObject };

package/storageAdapter.d.ts

@@ -0,0 +1,33 @@
+import { Duration } from './duration.js';
+
+/**
+ * Most basic interface for a storage implementation. This is designed to be
+ * quite easily implemented by users to plug in any new underlying storage.
+ */
+type StorageAdapter<T> = {
+    set: (key: string, value: T) => Promise<void> | void;
+    get: (key: string) => Promise<T | undefined> | T | undefined;
+    delete: (key: string) => Promise<void> | void;
+    clear: () => Promise<void> | void;
+};
+/** Most basic interface for stored object. */
+type StoredObject<T> = {
+    value: T;
+    storedMs: number;
+    expiryMs: number;
+};
+/**
+ * Full interface for a storage implementation. Each method can be either sync
+ * or async, and the interface works with either implementation scheme.
+ */
+type FullStorageAdapter<T> = StorageAdapter<T> & {
+    set: (key: string, value: T, expiryDeltaMs?: number | Duration) => Promise<void> | void;
+    getStoredObject: (key: string) => Promise<StoredObject<T> | undefined> | StoredObject<T> | undefined;
+    forEach(callback: (key: string, value: T, expiryMs: number, storedMs: number) => void | Promise<void>): Promise<void> | void;
+    size(): Promise<number> | number;
+    asMap<T>(): Promise<Map<string, StoredObject<T>>> | Map<string, StoredObject<T>>;
+    gc: () => Promise<void> | void;
+    gcNow: () => Promise<void> | void;
+};
+
+export type { FullStorageAdapter, StorageAdapter, StoredObject };

package/storageAdapter.min.cjs

@@ -0,0 +1,2 @@
+"use strict";var t=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var n=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var m=(r,e,d,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of n(e))!a.call(r,o)&&o!==d&&t(r,o,{get:()=>e[o],enumerable:!(i=s(e,o))||i.enumerable});return r};var v=r=>m(t({},"__esModule",{value:!0}),r);var u={};module.exports=v(u);
+//# sourceMappingURL=storageAdapter.min.cjs.map

package/storageAdapter.min.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storageAdapter.ts"],"sourcesContent":["import { Duration } from \"./duration\";\n\n/**\n * Most basic interface for a storage implementation. This is designed to be\n * quite easily implemented by users to plug in any new underlying storage.\n */\nexport type StorageAdapter<T> = {\n  set: (key: string, value: T) => Promise<void> | void;\n  get: (key: string) => Promise<T | undefined> | T | undefined;\n  delete: (key: string) => Promise<void> | void;\n  clear: () => Promise<void> | void;\n};\n\n/** Most basic interface for stored object. */\nexport type StoredObject<T> = {\n  value: T;\n  storedMs: number;\n  expiryMs: number;\n};\n\n/**\n * Full interface for a storage implementation. Each method can be either sync\n * or async, and the interface works with either implementation scheme.\n */\nexport type FullStorageAdapter<T> = StorageAdapter<T> & {\n  // Redefining `set()`, but with an optional expiration parameter.\n  set: (\n    key: string,\n    value: T,\n    expiryDeltaMs?: number | Duration,\n  ) => Promise<void> | void;\n\n  getStoredObject: (\n    key: string,\n  ) => Promise<StoredObject<T> | undefined> | StoredObject<T> | undefined;\n\n  forEach(\n    callback: (\n      key: string,\n      value: T,\n      expiryMs: number,\n      storedMs: number,\n    ) => void | Promise<void>,\n  ): Promise<void> | void;\n\n  size(): Promise<number> | number;\n\n  asMap<T>():\n    | Promise<Map<string, StoredObject<T>>>\n    | Map<string, StoredObject<T>>;\n\n  gc: () => Promise<void> | void;\n\n  gcNow: () => Promise<void> | void;\n};\n"],"mappings":"+WAAA,IAAAA,EAAA,kBAAAC,EAAAD","names":["storageAdapter_exports","__toCommonJS"]}

package/storageAdapter.min.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=storageAdapter.min.mjs.map

package/storageAdapter.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/sum.d.ts

@@ -2,4 +2,6 @@
  * Add all the numbers together in the given array. Treats null, undefined and
  * NaN as zero.
  */
-export declare function sum(numbers: (number | null | undefined)[]): number;
+declare function sum(numbers: (number | null | undefined)[]): number;
+
+export { sum };

package/timeConstants.d.ts

@@ -2,17 +2,19 @@
  * Note that month and year do not have fixed durations, and hence are excluded
  * from this file.
  */
-export declare const MS_PER_SECOND = 1000;
-export declare const MS_PER_MINUTE = 60000;
-export declare const MS_PER_HOUR = 3600000;
-export declare const MS_PER_DAY = 86400000;
-export declare const MS_PER_WEEK = 604800000;
-export declare const SECONDS_PER_MINUTE = 60;
-export declare const SECONDS_PER_HOUR = 3600;
-export declare const SECONDS_PER_DAY = 86400;
-export declare const SECONDS_PER_WEEK = 604800;
-export declare const MINUTES_PER_HOUR = 60;
-export declare const MINUTES_PER_DAY = 1440;
-export declare const MINUTES_PER_WEEK = 10080;
-export declare const HOURS_PER_DAY = 24;
-export declare const HOURS_PER_WEEK = 168;
+declare const MS_PER_SECOND = 1000;
+declare const MS_PER_MINUTE = 60000;
+declare const MS_PER_HOUR = 3600000;
+declare const MS_PER_DAY = 86400000;
+declare const MS_PER_WEEK = 604800000;
+declare const SECONDS_PER_MINUTE = 60;
+declare const SECONDS_PER_HOUR = 3600;
+declare const SECONDS_PER_DAY = 86400;
+declare const SECONDS_PER_WEEK = 604800;
+declare const MINUTES_PER_HOUR = 60;
+declare const MINUTES_PER_DAY = 1440;
+declare const MINUTES_PER_WEEK = 10080;
+declare const HOURS_PER_DAY = 24;
+declare const HOURS_PER_WEEK = 168;
+
+export { HOURS_PER_DAY, HOURS_PER_WEEK, MINUTES_PER_DAY, MINUTES_PER_HOUR, MINUTES_PER_WEEK, MS_PER_DAY, MS_PER_HOUR, MS_PER_MINUTE, MS_PER_SECOND, MS_PER_WEEK, SECONDS_PER_DAY, SECONDS_PER_HOUR, SECONDS_PER_MINUTE, SECONDS_PER_WEEK };

package/timer.d.ts

@@ -1,4 +1,4 @@
-export declare class Timer {
+declare class Timer {
     startMs: number;
     endMs: number;
     constructor();
@@ -8,4 +8,6 @@ export declare class Timer {
     toString(): string;
 }
 /** Shorthand for `new Timer()` to make this easier to use. */
-export declare function timer(): Timer;
+declare function timer(): Timer;
+
+export { Timer, timer };