@hyperfrontend/time-utils 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
+
+## 0.0.1 (2026-02-15)

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Redican
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,260 @@
+# @hyperfrontend/time-utils
+
+<p align="center">
+  <a href="https://github.com/AndrewRedican/hyperfrontend/actions/workflows/ci-lib-time-utils.yml">
+    <img src="https://img.shields.io/github/actions/workflow/status/AndrewRedican/hyperfrontend/ci-lib-time-utils.yml?style=flat-square&logo=github&label=build" alt="Build">
+  </a>
+  <a href="https://codecov.io/gh/AndrewRedican/hyperfrontend/flags?flags%5B0%5D=time-utils">
+    <img src="https://codecov.io/gh/AndrewRedican/hyperfrontend/graph/badge.svg?flag=time-utils" alt="Coverage">
+  </a>
+  <a href="https://www.npmjs.com/package/@hyperfrontend/time-utils">
+    <img src="https://img.shields.io/npm/v/@hyperfrontend/time-utils?style=flat-square" alt="npm version">
+  </a>
+</p>
+<p align="center">
+  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+  <a href="#contributors">
+    <img src="https://img.shields.io/github/all-contributors/AndrewRedican/hyperfrontend?color=ee8449&style=flat-square" alt="All Contributors">
+  </a>
+  <!-- ALL-CONTRIBUTORS-BADGE:END -->
+  <a href="https://github.com/AndrewRedican/hyperfrontend/blob/main/LICENSE.md">
+    <img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="License">
+  </a>
+  <a href="https://www.npmjs.com/package/@hyperfrontend/time-utils">
+    <img src="https://img.shields.io/npm/dm/@hyperfrontend/time-utils?style=flat-square" alt="npm downloads">
+  </a>
+  <a href="https://github.com/AndrewRedican/hyperfrontend">
+    <img src="https://img.shields.io/github/stars/AndrewRedican/hyperfrontend?style=flat-square" alt="GitHub stars">
+  </a>
+  <a href="https://bundlephobia.com/package/@hyperfrontend/time-utils">
+    <img src="https://img.shields.io/bundlephobia/minzip/@hyperfrontend/time-utils?style=flat-square" alt="Bundle Size">
+  </a>
+  <img src="https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen?style=flat-square&logo=node.js" alt="Node Version">
+  <img src="https://img.shields.io/badge/tree%20shakeable-%E2%9C%93-success?style=flat-square" alt="Tree Shakeable">
+</p>
+
+Functional time utilities for async operations, intervals, and time normalization.
+
+## What is @hyperfrontend/time-utils?
+
+`@hyperfrontend/time-utils` provides composable, testable utilities for working with time-based operations in JavaScript. The library focuses on enhancing the control and flexibility of standard timing APIs (`setTimeout`, `setInterval`) while adding specialized utilities for async workflows and time window calculations.
+
+Unlike the native timing APIs which offer limited lifecycle control, this library wraps them in functional interfaces that support pausing, resuming, resetting, and subscription management. All utilities return immutable objects with frozen APIs, preventing accidental mutation while maintaining predictable behavior.
+
+### Key Features
+
+- **Controllable timers** - Pause, resume, and reset `setTimeout` operations with tracked remaining time
+- **Multi-subscriber clocks** - Observable interval loops supporting multiple callbacks with unified start/stop control
+- **Promise-based delays** - Async/await compatible `sleep()` utility for sequential code flows
+- **Time window normalization** - Bucket timestamps into fixed intervals (e.g., 5-minute windows for aggregation)
+- **Functional cleanup** - All repeating operations return cleanup functions for straightforward teardown
+- **Immutable APIs** - All returned objects are frozen, preventing accidental state modifications
+- **Zero dependencies** - Self-contained timing utilities with no external dependencies
+- **TypeScript native** - Full type definitions with comprehensive JSDoc documentation
+
+### Architecture Highlights
+
+All timing abstractions maintain internal state privately while exposing frozen API objects, following the revealing module pattern. Timer implementations track elapsed time explicitly to enable pause/resume functionality, while clock implementations manage subscriber arrays with simple filter-based unsubscription. The library avoids classes and prototypes in favor of factory functions that return object literals.
+
+## Why Use @hyperfrontend/time-utils?
+
+### 1. Pause/Resume Capabilities Native APIs Lack
+
+JavaScript's `setTimeout` and `setInterval` cannot be paused—once started, they either complete or get cancelled. This creates problems for features like user-initiated pauses in games, animations during background tabs, or request throttling. `createTimer()` tracks elapsed time internally, enabling pause/resume without restarting from the beginning or losing progress.
+
+**Example:** A countdown timer in a game needs to pause when the user switches tabs. With `setTimeout`, you'd need to calculate remaining time manually and create a new timeout. With `createTimer`, just call `timer.pause()`.
+
+### 2. Multi-Subscriber Interval Management
+
+Native `setInterval` requires creating separate intervals for each callback that needs to run at the same frequency, leading to drift and coordination issues. `createClock()` lets multiple callbacks subscribe to a single interval loop, ensuring they all fire synchronously at exact intervals. Perfect for real-time dashboards, clocks, or animation frames.
+
+**Example:** A dashboard with 5 widgets updating every second would require 5 separate `setInterval` calls, potentially drifting apart. A single clock can notify all widgets simultaneously from one interval.
+
+### 3. Async/Await Integration for Sequential Delays
+
+Writing readable sequential code with delays requires nested callbacks or promise chains with `setTimeout`. `sleep()` provides a clean async/await compatible delay utility that works naturally with modern async functions. This is essential for testing, retry logic, rate limiting, and animation sequences.
+
+**Example:** Retry logic becomes `await sleep(1000); retry()` instead of `setTimeout(() => retry(), 1000)`, maintaining the sequential flow of async functions.
+
+### 4. Time Window Normalization for Aggregation
+
+Real-time data aggregation often requires grouping events into time buckets (5-minute windows, hourly intervals, etc.). `normalizeToBaseTimeWindow()` rounds timestamps down to the nearest window boundary, simplifying time-series data grouping for metrics, logs, and analytics.
+
+**Example:** Events at 10:03, 10:07, and 10:12 with a 5-minute window all normalize to 10:00, 10:05, and 10:10 respectively, creating clean bucket keys for aggregation.
+
+### 5. Immutable, Testable Timing Abstractions
+
+Testing code with `setTimeout` and `setInterval` typically requires jest timers or sinon fakes, adding complexity. These utilities use standard timing APIs internally but expose functional interfaces that are easier to mock and test. The frozen return objects prevent accidental mutations that could cause subtle timing bugs.
+
+## Installation
+
+```bash
+npm install @hyperfrontend/time-utils
+```
+
+## Quick Start
+
+**Pauseable timer:**
+
+```typescript
+import { createTimer } from '@hyperfrontend/time-utils'
+
+const timer = createTimer(() => console.log('Done!'), 5000)
+
+timer.resume() // Start the 5-second countdown
+
+// After 3 seconds, user pauses
+timer.pause() // Pauses with 2 seconds remaining
+
+// Later, resume from where we left off
+timer.resume() // Continues with remaining 2 seconds
+
+// Or reset with a new duration
+timer.reset(10000) // Restart with 10 seconds
+```
+
+**Multi-subscriber clock:**
+
+```typescript
+import { createClock } from '@hyperfrontend/time-utils'
+
+// Create a clock that ticks every second
+const clock = createClock(1000)
+
+// Multiple subscribers can listen
+clock.subscribe((time) => console.log('Widget 1:', time))
+clock.subscribe((time) => console.log('Widget 2:', time))
+
+clock.start() // Both widgets update every second
+
+// Later, stop all updates
+clock.stop()
+
+// Unsubscribe specific callbacks
+clock.unsubscribe(callback)
+```
+
+**Async delays:**
+
+```typescript
+import { sleep } from '@hyperfrontend/time-utils'
+
+async function retryWithDelay(fn, attempts = 3) {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn()
+    } catch (error) {
+      if (i < attempts - 1) {
+        await sleep(1000 * Math.pow(2, i)) // Exponential backoff
+      }
+    }
+  }
+  throw new Error('All retries failed')
+}
+```
+
+**Time window normalization:**
+
+```typescript
+import { normalizeToBaseTimeWindow } from '@hyperfrontend/time-utils'
+
+// Group metrics into 5-minute windows
+const events = [new Date('2024-01-17T10:03:45Z'), new Date('2024-01-17T10:07:22Z'), new Date('2024-01-17T10:12:03Z')]
+
+const buckets = new Map()
+events.forEach((timestamp) => {
+  const bucket = normalizeToBaseTimeWindow(timestamp, 5)
+  const key = bucket.toISOString()
+  buckets.set(key, (buckets.get(key) || 0) + 1)
+})
+
+// Results:
+// "2024-01-17T10:00:00Z" → 2 events
+// "2024-01-17T10:10:00Z" → 1 event
+```
+
+**Simple interval with cleanup:**
+
+```typescript
+import { setIntervalCallback } from '@hyperfrontend/time-utils'
+
+// Returns a cleanup function
+const cleanup = setIntervalCallback(() => {
+  console.log('Polling...')
+}, 5000)
+
+// Later, stop polling
+cleanup()
+```
+
+## API Overview
+
+**Timing Abstractions:**
+
+- **`createTimer(callback, delay)`** - Creates a pauseable, resumable timer (enhanced setTimeout)
+  - `timer.pause()` - Pauses timer, preserving remaining time
+  - `timer.resume()` - Resumes timer from remaining time
+  - `timer.reset(newDelay?)` - Restarts timer with optional new duration
+
+- **`createClock(interval?)`** - Creates a multi-subscriber interval loop (default: 1000ms)
+  - `clock.start()` - Begins interval loop
+  - `clock.stop()` - Stops interval loop
+  - `clock.subscribe(callback)` - Adds callback to subscriber list
+  - `clock.unsubscribe(callback)` - Removes callback from subscribers
+  - `clock.interval` - Read-only interval duration
+
+**Utility Functions:**
+
+- **`sleep(milliseconds)`** - Returns promise that resolves after delay (async/await compatible)
+- **`setIntervalCallback(callback, interval)`** - Simple setInterval wrapper returning cleanup function
+- **`normalizeToBaseTimeWindow(time, baseTimeWindow)`** - Rounds timestamp down to nearest time window boundary (window in minutes)
+
+## Compatibility
+
+| Platform                      | Support |
+| ----------------------------- | :-----: |
+| Browser                       |   ✅    |
+| Node.js                       |   ✅    |
+| Web Workers                   |   ✅    |
+| Deno, Bun, Cloudflare Workers |   ✅    |
+
+### Output Formats
+
+| Format | File                       | Tree-Shakeable |
+| ------ | -------------------------- | :------------: |
+| ESM    | `index.esm.js`             |       ✅       |
+| CJS    | `index.cjs.js`             |       ❌       |
+| IIFE   | `bundle/index.iife.min.js` |       ❌       |
+| UMD    | `bundle/index.umd.min.js`  |       ❌       |
+
+**Bundle size:** 1 KB (minified, self-contained)
+
+### CDN Usage
+
+```html
+<!-- unpkg -->
+<script src="https://unpkg.com/@hyperfrontend/time-utils"></script>
+
+<!-- jsDelivr -->
+<script src="https://cdn.jsdelivr.net/npm/@hyperfrontend/time-utils"></script>
+
+<script>
+  const { createResumableInterval, sleep } = HyperfrontendTimeUtils
+</script>
+```
+
+**Global variable:** `HyperfrontendTimeUtils`
+
+### Dependencies
+
+None — zero external dependencies.
+
+## Part of hyperfrontend
+
+This library is part of the [hyperfrontend](https://github.com/AndrewRedican/hyperfrontend) monorepo. [Full documentation](https://hyperfrontend.dev).
+
+- Used by [@hyperfrontend/cryptography](https://github.com/AndrewRedican/hyperfrontend/tree/main/libs/cryptography) for time-window password generation
+
+## License
+
+MIT

package/SECURITY.md

@@ -0,0 +1,82 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+We take the security of hyperfrontend seriously. If you discover a security vulnerability, please help us protect our users by following responsible disclosure practices.
+
+### How to Report
+
+**Please DO NOT report security vulnerabilities through public GitHub issues.**
+
+Instead, please report security vulnerabilities directly via email to:
+
+**<andrew.redican.mejia@gmail.com>**
+
+### What to Include
+
+To help us understand and resolve the issue quickly, please include the following information in your report:
+
+- **Description**: A clear description of the vulnerability
+- **Impact**: The potential impact and severity of the issue
+- **Reproduction Steps**: Detailed steps to reproduce the vulnerability
+- **Environment**: The version of hyperfrontend affected, browser/Node.js version, operating system, etc.
+- **Proof of Concept**: If possible, include a minimal code example or proof of concept
+- **Suggested Fix**: If you have ideas on how to fix the issue (optional)
+
+### Response Timeline
+
+- **Acknowledgment**: We will acknowledge receipt of your vulnerability report within 2 business days
+- **Initial Assessment**: We will provide an initial assessment within 5 business days
+- **Patch Development**: We aim to develop and test a patch within 10 days of acknowledgment
+- **Public Disclosure**: Please allow at least **10 days** from the initial report before making the vulnerability publicly known
+
+This grace period gives us time to:
+
+- Verify and reproduce the issue
+- Develop and test a fix
+- Release a patched version
+- Notify users to update their dependencies
+
+### Coordinated Disclosure
+
+We believe in coordinated disclosure and appreciate your cooperation in:
+
+- Not exploiting the vulnerability beyond what is necessary to demonstrate it
+- Not accessing, modifying, or deleting data that doesn't belong to you
+- Allowing us reasonable time to address the issue before public disclosure
+- Making a good faith effort to avoid privacy violations, data destruction, and service interruption
+
+### Recognition
+
+Once the vulnerability is patched and publicly disclosed, we will acknowledge your responsible disclosure in:
+
+- Our release notes
+- Our security advisories (if applicable)
+- This SECURITY.md file (with your permission)
+
+Thank you for helping keep hyperfrontend and its users safe!
+
+## Security Best Practices
+
+When using hyperfrontend in your applications:
+
+1. **Keep Dependencies Updated**: Regularly update to the latest version to receive security patches
+2. **Content Security Policy**: Implement appropriate CSP headers when embedding features
+3. **Input Validation**: Validate and sanitize all data passed between features
+4. **Origin Verification**: Always verify the origin of messages in cross-frame communication
+5. **Authentication**: Implement proper authentication and authorization for sensitive features
+6. **HTTPS**: Always serve hyperfrontend features over HTTPS in production
+
+## Security Updates
+
+Security updates will be released as patch versions and documented in the [CHANGELOG](https://github.com/AndrewRedican/hyperfrontend/releases) and GitHub Security Advisories.
+
+## Supported Versions
+
+We currently provide security updates for:
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 0.0.x   | :white_check_mark: |
+
+As the project matures, we will update this table to reflect our long-term support policy.

package/bundle/index.iife.js

@@ -0,0 +1,131 @@
+var HyperfrontendTimeUtils = (function (exports) {
+    'use strict';
+
+    /**
+     * Creates an interval loop that invokes one or more subscribed callback functions
+     * at the specified internal (in milliseconds).
+     *
+     * Allows you to start or stop the interval loop, much like a stop watch.
+     * Allows you to unsubscribe callback functions.
+     *
+     * @param interval - Time in milliseconds between each callback invocation (default: 1000ms)
+     * @returns A Clock instance with start, stop, subscribe, and unsubscribe methods
+     */
+    function createClock(interval = 1000) {
+        let clockId = null;
+        let subscribers = [];
+        const start = () => {
+            if (clockId === null) {
+                clockId = setInterval(() => {
+                    const currentTime = new Date();
+                    subscribers.forEach((subscriber) => subscriber(currentTime));
+                }, interval);
+            }
+        };
+        const stop = () => {
+            if (clockId !== null) {
+                clearInterval(clockId);
+                clockId = null;
+            }
+        };
+        const subscribe = (callback) => {
+            subscribers.push(callback);
+        };
+        const unsubscribe = (callback) => {
+            subscribers = subscribers.filter((subscriber) => subscriber !== callback);
+        };
+        return Object.freeze({ start, stop, subscribe, unsubscribe, interval });
+    }
+
+    /**
+     * Invokes callback function after the designated time has passed, much like a timer.
+     * Allows you to pause, resume, or reset the progress of time tracked.
+     *
+     * @param callback - The function to invoke after the delay
+     * @param delay - Time in milliseconds to wait until callback is invoked
+     * @returns A Timer instance with pause, resume, and reset methods
+     */
+    function createTimer(callback, delay) {
+        let timerId = null;
+        let start = null;
+        let remaining = delay;
+        const pause = () => {
+            if (timerId !== null) {
+                clearTimeout(timerId);
+                const now = Date.now();
+                /* istanbul ignore else - start is always set when timerId is not null */
+                if (start !== null) {
+                    remaining -= now - start;
+                }
+                timerId = null;
+            }
+        };
+        const resume = () => {
+            if (timerId === null) {
+                start = Date.now();
+                timerId = setTimeout(() => {
+                    callback();
+                    timerId = null;
+                }, remaining);
+            }
+        };
+        const reset = (newDelay = delay) => {
+            pause();
+            remaining = newDelay;
+            resume();
+        };
+        return Object.freeze({ pause, resume, reset });
+    }
+
+    /**
+     * Normalizes a given time to the nearest base time window.
+     *
+     * @param time - The Date object to normalize to the nearest time window
+     * @param baseTimeWindow - The size of the time window in minutes for normalization
+     * @returns A new Date object normalized to the start of the time window
+     */
+    function normalizeToBaseTimeWindow(time, baseTimeWindow) {
+        if (!time || !(time instanceof Date) || isNaN(time.getTime())) {
+            throw new Error('Invalid time input');
+        }
+        if (baseTimeWindow <= 0) {
+            throw new Error('Base time window must be positive');
+        }
+        const timeInMs = time.getTime();
+        const windowInMs = baseTimeWindow * 60 * 1000;
+        const normalizedTimeInMs = Math.floor(timeInMs / windowInMs) * windowInMs;
+        return new Date(normalizedTimeInMs);
+    }
+
+    /**
+     * Creates a repeating interval that invokes a callback function at regular intervals.
+     *
+     * @param callback - The function to invoke at each interval
+     * @param interval - Time in milliseconds between each callback invocation
+     * @returns A cleanup function that stops the interval when called
+     */
+    function setIntervalCallback(callback, interval) {
+        const timerId = setInterval(callback, interval);
+        return () => clearInterval(timerId);
+    }
+
+    /**
+     * Pauses execution for a specified duration.
+     *
+     * @param milliseconds - The duration to sleep in milliseconds
+     * @returns A promise that resolves after the specified duration
+     */
+    function sleep(milliseconds) {
+        return new Promise((resolve) => setTimeout(resolve, milliseconds));
+    }
+
+    exports.createClock = createClock;
+    exports.createTimer = createTimer;
+    exports.normalizeToBaseTimeWindow = normalizeToBaseTimeWindow;
+    exports.setIntervalCallback = setIntervalCallback;
+    exports.sleep = sleep;
+
+    return exports;
+
+})({});
+//# sourceMappingURL=index.iife.js.map

package/bundle/index.iife.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.iife.js","sources":["../../../../../../../../../../libs/utils/time/src/create-clock.ts","../../../../../../../../../../libs/utils/time/src/create-timer.ts","../../../../../../../../../../libs/utils/time/src/normalize-to-base-time-window.ts","../../../../../../../../../../libs/utils/time/src/set-interval-callback.ts","../../../../../../../../../../libs/utils/time/src/sleep.ts"],"sourcesContent":[null,null,null,null,null],"names":[],"mappings":"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"}

package/bundle/index.iife.min.js

@@ -0,0 +1,2 @@
+var HyperfrontendTimeUtils=function(e){"use strict";return e.createClock=function(e=1e3){let t=null,n=[];return Object.freeze({start:()=>{null===t&&(t=setInterval(()=>{const e=new Date;n.forEach(t=>t(e))},e))},stop:()=>{null!==t&&(clearInterval(t),t=null)},subscribe:e=>{n.push(e)},unsubscribe:e=>{n=n.filter(t=>t!==e)},interval:e})},e.createTimer=function(e,t){let n=null,r=null,l=t;const i=()=>{if(null!==n){clearTimeout(n);const e=Date.now();null!==r&&(l-=e-r),n=null}},u=()=>{null===n&&(r=Date.now(),n=setTimeout(()=>{e(),n=null},l))};return Object.freeze({pause:i,resume:u,reset:(e=t)=>{i(),l=e,u()}})},e.normalizeToBaseTimeWindow=function(e,t){if(!e||!(e instanceof Date)||isNaN(e.getTime()))throw new Error("Invalid time input");if(t<=0)throw new Error("Base time window must be positive");const n=e.getTime(),r=60*t*1e3,l=Math.floor(n/r)*r;return new Date(l)},e.setIntervalCallback=function(e,t){const n=setInterval(e,t);return()=>clearInterval(n)},e.sleep=function(e){return new Promise(t=>setTimeout(t,e))},e}({});
+//# sourceMappingURL=index.iife.min.js.map

package/bundle/index.iife.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.iife.min.js","sources":["../../../../../../../../../../libs/utils/time/src/create-clock.ts","../../../../../../../../../../libs/utils/time/src/create-timer.ts","../../../../../../../../../../libs/utils/time/src/normalize-to-base-time-window.ts","../../../../../../../../../../libs/utils/time/src/set-interval-callback.ts","../../../../../../../../../../libs/utils/time/src/sleep.ts"],"sourcesContent":[null,null,null,null,null],"names":["interval","clockId","subscribers","Object","freeze","start","setInterval","currentTime","Date","forEach","subscriber","stop","clearInterval","subscribe","callback","push","unsubscribe","filter","delay","timerId","remaining","pause","clearTimeout","now","resume","setTimeout","reset","newDelay","time","baseTimeWindow","isNaN","getTime","Error","timeInMs","windowInMs","normalizedTimeInMs","Math","floor","milliseconds","Promise","resolve"],"mappings":"yEAmBM,SAAsBA,EAAW,KACrC,IAAIC,EAAiC,KACjCC,EAA+C,GA0BnD,OAAOC,OAAOC,OAAO,CAAEC,MAxBT,KACI,OAAZJ,IACFA,EAAUK,YAAY,KACpB,MAAMC,EAAc,IAAIC,KACxBN,EAAYO,QAASC,GAAeA,EAAWH,KAC9CP,KAmBuBW,KAfjB,KACK,OAAZV,IACFW,cAAcX,GACdA,EAAU,OAYsBY,UARjBC,IACjBZ,EAAYa,KAAKD,IAO4BE,YAJ1BF,IACnBZ,EAAcA,EAAYe,OAAQP,GAAeA,IAAeI,IAGNd,YAC9D,gBC/BM,SAAsBc,EAAsBI,GAChD,IAAIC,EAAiC,KACjCd,EAAuB,KACvBe,EAAoBF,EAExB,MAAMG,EAAQ,KACZ,GAAgB,OAAZF,EAAkB,CACpBG,aAAaH,GACb,MAAMI,EAAMf,KAAKe,MAEH,OAAVlB,IACFe,GAAaG,EAAMlB,GAErBc,EAAU,IACZ,GAGIK,EAAS,KACG,OAAZL,IACFd,EAAQG,KAAKe,MACbJ,EAAUM,WAAW,KACnBX,IACAK,EAAU,MACTC,KAUP,OAAOjB,OAAOC,OAAO,CAAEiB,QAAOG,SAAQE,MANxB,CAACC,EAAmBT,KAChCG,IACAD,EAAYO,EACZH,MAIJ,8BC5CM,SAAoCI,EAAYC,GACpD,IAAKD,KAAUA,aAAgBpB,OAASsB,MAAMF,EAAKG,WACjD,MAAM,IAAIC,MAAM,sBAGlB,GAAIH,GAAkB,EACpB,MAAM,IAAIG,MAAM,qCAGlB,MAAMC,EAAWL,EAAKG,UAChBG,EAA8B,GAAjBL,EAAsB,IACnCM,EAAqBC,KAAKC,MAAMJ,EAAWC,GAAcA,EAC/D,OAAO,IAAI1B,KAAK2B,EAClB,wBCbM,SAA8BrB,EAAsBd,GACxD,MAAMmB,EAA0Bb,YAAYQ,EAAUd,GACtD,MAAO,IAAYY,cAAcO,EACnC,UCJM,SAAgBmB,GACpB,OAAO,IAAIC,QAASC,GAAYf,WAAWe,EAASF,GACtD"}

package/bundle/index.umd.js

@@ -0,0 +1,132 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.HyperfrontendTimeUtils = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Creates an interval loop that invokes one or more subscribed callback functions
+     * at the specified internal (in milliseconds).
+     *
+     * Allows you to start or stop the interval loop, much like a stop watch.
+     * Allows you to unsubscribe callback functions.
+     *
+     * @param interval - Time in milliseconds between each callback invocation (default: 1000ms)
+     * @returns A Clock instance with start, stop, subscribe, and unsubscribe methods
+     */
+    function createClock(interval = 1000) {
+        let clockId = null;
+        let subscribers = [];
+        const start = () => {
+            if (clockId === null) {
+                clockId = setInterval(() => {
+                    const currentTime = new Date();
+                    subscribers.forEach((subscriber) => subscriber(currentTime));
+                }, interval);
+            }
+        };
+        const stop = () => {
+            if (clockId !== null) {
+                clearInterval(clockId);
+                clockId = null;
+            }
+        };
+        const subscribe = (callback) => {
+            subscribers.push(callback);
+        };
+        const unsubscribe = (callback) => {
+            subscribers = subscribers.filter((subscriber) => subscriber !== callback);
+        };
+        return Object.freeze({ start, stop, subscribe, unsubscribe, interval });
+    }
+
+    /**
+     * Invokes callback function after the designated time has passed, much like a timer.
+     * Allows you to pause, resume, or reset the progress of time tracked.
+     *
+     * @param callback - The function to invoke after the delay
+     * @param delay - Time in milliseconds to wait until callback is invoked
+     * @returns A Timer instance with pause, resume, and reset methods
+     */
+    function createTimer(callback, delay) {
+        let timerId = null;
+        let start = null;
+        let remaining = delay;
+        const pause = () => {
+            if (timerId !== null) {
+                clearTimeout(timerId);
+                const now = Date.now();
+                /* istanbul ignore else - start is always set when timerId is not null */
+                if (start !== null) {
+                    remaining -= now - start;
+                }
+                timerId = null;
+            }
+        };
+        const resume = () => {
+            if (timerId === null) {
+                start = Date.now();
+                timerId = setTimeout(() => {
+                    callback();
+                    timerId = null;
+                }, remaining);
+            }
+        };
+        const reset = (newDelay = delay) => {
+            pause();
+            remaining = newDelay;
+            resume();
+        };
+        return Object.freeze({ pause, resume, reset });
+    }
+
+    /**
+     * Normalizes a given time to the nearest base time window.
+     *
+     * @param time - The Date object to normalize to the nearest time window
+     * @param baseTimeWindow - The size of the time window in minutes for normalization
+     * @returns A new Date object normalized to the start of the time window
+     */
+    function normalizeToBaseTimeWindow(time, baseTimeWindow) {
+        if (!time || !(time instanceof Date) || isNaN(time.getTime())) {
+            throw new Error('Invalid time input');
+        }
+        if (baseTimeWindow <= 0) {
+            throw new Error('Base time window must be positive');
+        }
+        const timeInMs = time.getTime();
+        const windowInMs = baseTimeWindow * 60 * 1000;
+        const normalizedTimeInMs = Math.floor(timeInMs / windowInMs) * windowInMs;
+        return new Date(normalizedTimeInMs);
+    }
+
+    /**
+     * Creates a repeating interval that invokes a callback function at regular intervals.
+     *
+     * @param callback - The function to invoke at each interval
+     * @param interval - Time in milliseconds between each callback invocation
+     * @returns A cleanup function that stops the interval when called
+     */
+    function setIntervalCallback(callback, interval) {
+        const timerId = setInterval(callback, interval);
+        return () => clearInterval(timerId);
+    }
+
+    /**
+     * Pauses execution for a specified duration.
+     *
+     * @param milliseconds - The duration to sleep in milliseconds
+     * @returns A promise that resolves after the specified duration
+     */
+    function sleep(milliseconds) {
+        return new Promise((resolve) => setTimeout(resolve, milliseconds));
+    }
+
+    exports.createClock = createClock;
+    exports.createTimer = createTimer;
+    exports.normalizeToBaseTimeWindow = normalizeToBaseTimeWindow;
+    exports.setIntervalCallback = setIntervalCallback;
+    exports.sleep = sleep;
+
+}));
+//# sourceMappingURL=index.umd.js.map

package/bundle/index.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.umd.js","sources":["../../../../../../../../../../libs/utils/time/src/create-clock.ts","../../../../../../../../../../libs/utils/time/src/create-timer.ts","../../../../../../../../../../libs/utils/time/src/normalize-to-base-time-window.ts","../../../../../../../../../../libs/utils/time/src/set-interval-callback.ts","../../../../../../../../../../libs/utils/time/src/sleep.ts"],"sourcesContent":[null,null,null,null,null],"names":[],"mappings":"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"}

package/bundle/index.umd.min.js

@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).HyperfrontendTimeUtils={})}(this,function(e){"use strict";e.createClock=function(e=1e3){let t=null,n=[];return Object.freeze({start:()=>{null===t&&(t=setInterval(()=>{const e=new Date;n.forEach(t=>t(e))},e))},stop:()=>{null!==t&&(clearInterval(t),t=null)},subscribe:e=>{n.push(e)},unsubscribe:e=>{n=n.filter(t=>t!==e)},interval:e})},e.createTimer=function(e,t){let n=null,l=null,r=t;const o=()=>{if(null!==n){clearTimeout(n);const e=Date.now();null!==l&&(r-=e-l),n=null}},i=()=>{null===n&&(l=Date.now(),n=setTimeout(()=>{e(),n=null},r))};return Object.freeze({pause:o,resume:i,reset:(e=t)=>{o(),r=e,i()}})},e.normalizeToBaseTimeWindow=function(e,t){if(!e||!(e instanceof Date)||isNaN(e.getTime()))throw new Error("Invalid time input");if(t<=0)throw new Error("Base time window must be positive");const n=e.getTime(),l=60*t*1e3,r=Math.floor(n/l)*l;return new Date(r)},e.setIntervalCallback=function(e,t){const n=setInterval(e,t);return()=>clearInterval(n)},e.sleep=function(e){return new Promise(t=>setTimeout(t,e))}});
+//# sourceMappingURL=index.umd.min.js.map

package/bundle/index.umd.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.umd.min.js","sources":["../../../../../../../../../../libs/utils/time/src/create-clock.ts","../../../../../../../../../../libs/utils/time/src/create-timer.ts","../../../../../../../../../../libs/utils/time/src/normalize-to-base-time-window.ts","../../../../../../../../../../libs/utils/time/src/set-interval-callback.ts","../../../../../../../../../../libs/utils/time/src/sleep.ts"],"sourcesContent":[null,null,null,null,null],"names":["interval","clockId","subscribers","Object","freeze","start","setInterval","currentTime","Date","forEach","subscriber","stop","clearInterval","subscribe","callback","push","unsubscribe","filter","delay","timerId","remaining","pause","clearTimeout","now","resume","setTimeout","reset","newDelay","time","baseTimeWindow","isNaN","getTime","Error","timeInMs","windowInMs","normalizedTimeInMs","Math","floor","milliseconds","Promise","resolve"],"mappings":"2QAmBM,SAAsBA,EAAW,KACrC,IAAIC,EAAiC,KACjCC,EAA+C,GA0BnD,OAAOC,OAAOC,OAAO,CAAEC,MAxBT,KACI,OAAZJ,IACFA,EAAUK,YAAY,KACpB,MAAMC,EAAc,IAAIC,KACxBN,EAAYO,QAASC,GAAeA,EAAWH,KAC9CP,KAmBuBW,KAfjB,KACK,OAAZV,IACFW,cAAcX,GACdA,EAAU,OAYsBY,UARjBC,IACjBZ,EAAYa,KAAKD,IAO4BE,YAJ1BF,IACnBZ,EAAcA,EAAYe,OAAQP,GAAeA,IAAeI,IAGNd,YAC9D,gBC/BM,SAAsBc,EAAsBI,GAChD,IAAIC,EAAiC,KACjCd,EAAuB,KACvBe,EAAoBF,EAExB,MAAMG,EAAQ,KACZ,GAAgB,OAAZF,EAAkB,CACpBG,aAAaH,GACb,MAAMI,EAAMf,KAAKe,MAEH,OAAVlB,IACFe,GAAaG,EAAMlB,GAErBc,EAAU,IACZ,GAGIK,EAAS,KACG,OAAZL,IACFd,EAAQG,KAAKe,MACbJ,EAAUM,WAAW,KACnBX,IACAK,EAAU,MACTC,KAUP,OAAOjB,OAAOC,OAAO,CAAEiB,QAAOG,SAAQE,MANxB,CAACC,EAAmBT,KAChCG,IACAD,EAAYO,EACZH,MAIJ,8BC5CM,SAAoCI,EAAYC,GACpD,IAAKD,KAAUA,aAAgBpB,OAASsB,MAAMF,EAAKG,WACjD,MAAM,IAAIC,MAAM,sBAGlB,GAAIH,GAAkB,EACpB,MAAM,IAAIG,MAAM,qCAGlB,MAAMC,EAAWL,EAAKG,UAChBG,EAA8B,GAAjBL,EAAsB,IACnCM,EAAqBC,KAAKC,MAAMJ,EAAWC,GAAcA,EAC/D,OAAO,IAAI1B,KAAK2B,EAClB,wBCbM,SAA8BrB,EAAsBd,GACxD,MAAMmB,EAA0Bb,YAAYQ,EAAUd,GACtD,MAAO,IAAYY,cAAcO,EACnC,UCJM,SAAgBmB,GACpB,OAAO,IAAIC,QAASC,GAAYf,WAAWe,EAASF,GACtD"}

package/create-clock.d.ts

@@ -0,0 +1,20 @@
+export interface Clock {
+    readonly start: () => void;
+    readonly stop: () => void;
+    readonly subscribe: (callback: (currentTime: Date) => void) => void;
+    readonly unsubscribe: (callback: (currentTime: Date) => void) => void;
+    /** Interval in milliseconds */
+    readonly interval: number;
+}
+/**
+ * Creates an interval loop that invokes one or more subscribed callback functions
+ * at the specified internal (in milliseconds).
+ *
+ * Allows you to start or stop the interval loop, much like a stop watch.
+ * Allows you to unsubscribe callback functions.
+ *
+ * @param interval - Time in milliseconds between each callback invocation (default: 1000ms)
+ * @returns A Clock instance with start, stop, subscribe, and unsubscribe methods
+ */
+export declare function createClock(interval?: number): Clock;
+//# sourceMappingURL=create-clock.d.ts.map

package/create-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-clock.d.ts","sourceRoot":"","sources":["../../../../libs/utils/time/src/create-clock.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,IAAI,KAAK,IAAI,KAAK,IAAI,CAAA;IACnE,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,IAAI,KAAK,IAAI,KAAK,IAAI,CAAA;IACrE,+BAA+B;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,QAAQ,SAAO,GAAG,KAAK,CA6BlD"}

package/create-timer.d.ts

@@ -0,0 +1,18 @@
+export interface Timer {
+    /** Stops the progression of tracked time until further notice. */
+    readonly pause: () => void;
+    /** Reinstates the progression of tracked time. */
+    readonly resume: () => void;
+    /** Assigns a new wait time before function is invoked. */
+    readonly reset: (newDelay?: number) => void;
+}
+/**
+ * Invokes callback function after the designated time has passed, much like a timer.
+ * Allows you to pause, resume, or reset the progress of time tracked.
+ *
+ * @param callback - The function to invoke after the delay
+ * @param delay - Time in milliseconds to wait until callback is invoked
+ * @returns A Timer instance with pause, resume, and reset methods
+ */
+export declare function createTimer(callback: () => void, delay: number): Timer;
+//# sourceMappingURL=create-timer.d.ts.map

package/create-timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-timer.d.ts","sourceRoot":"","sources":["../../../../libs/utils/time/src/create-timer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IACpB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAA;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAC5C;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAkCtE"}

package/index.cjs.js

@@ -0,0 +1,126 @@
+'use strict';
+
+/**
+ * Creates an interval loop that invokes one or more subscribed callback functions
+ * at the specified internal (in milliseconds).
+ *
+ * Allows you to start or stop the interval loop, much like a stop watch.
+ * Allows you to unsubscribe callback functions.
+ *
+ * @param interval - Time in milliseconds between each callback invocation (default: 1000ms)
+ * @returns A Clock instance with start, stop, subscribe, and unsubscribe methods
+ */
+function createClock(interval = 1000) {
+    let clockId = null;
+    let subscribers = [];
+    const start = () => {
+        if (clockId === null) {
+            clockId = setInterval(() => {
+                const currentTime = new Date();
+                subscribers.forEach((subscriber) => subscriber(currentTime));
+            }, interval);
+        }
+    };
+    const stop = () => {
+        if (clockId !== null) {
+            clearInterval(clockId);
+            clockId = null;
+        }
+    };
+    const subscribe = (callback) => {
+        subscribers.push(callback);
+    };
+    const unsubscribe = (callback) => {
+        subscribers = subscribers.filter((subscriber) => subscriber !== callback);
+    };
+    return Object.freeze({ start, stop, subscribe, unsubscribe, interval });
+}
+
+/**
+ * Invokes callback function after the designated time has passed, much like a timer.
+ * Allows you to pause, resume, or reset the progress of time tracked.
+ *
+ * @param callback - The function to invoke after the delay
+ * @param delay - Time in milliseconds to wait until callback is invoked
+ * @returns A Timer instance with pause, resume, and reset methods
+ */
+function createTimer(callback, delay) {
+    let timerId = null;
+    let start = null;
+    let remaining = delay;
+    const pause = () => {
+        if (timerId !== null) {
+            clearTimeout(timerId);
+            const now = Date.now();
+            /* istanbul ignore else - start is always set when timerId is not null */
+            if (start !== null) {
+                remaining -= now - start;
+            }
+            timerId = null;
+        }
+    };
+    const resume = () => {
+        if (timerId === null) {
+            start = Date.now();
+            timerId = setTimeout(() => {
+                callback();
+                timerId = null;
+            }, remaining);
+        }
+    };
+    const reset = (newDelay = delay) => {
+        pause();
+        remaining = newDelay;
+        resume();
+    };
+    return Object.freeze({ pause, resume, reset });
+}
+
+/**
+ * Normalizes a given time to the nearest base time window.
+ *
+ * @param time - The Date object to normalize to the nearest time window
+ * @param baseTimeWindow - The size of the time window in minutes for normalization
+ * @returns A new Date object normalized to the start of the time window
+ */
+function normalizeToBaseTimeWindow(time, baseTimeWindow) {
+    if (!time || !(time instanceof Date) || isNaN(time.getTime())) {
+        throw new Error('Invalid time input');
+    }
+    if (baseTimeWindow <= 0) {
+        throw new Error('Base time window must be positive');
+    }
+    const timeInMs = time.getTime();
+    const windowInMs = baseTimeWindow * 60 * 1000;
+    const normalizedTimeInMs = Math.floor(timeInMs / windowInMs) * windowInMs;
+    return new Date(normalizedTimeInMs);
+}
+
+/**
+ * Creates a repeating interval that invokes a callback function at regular intervals.
+ *
+ * @param callback - The function to invoke at each interval
+ * @param interval - Time in milliseconds between each callback invocation
+ * @returns A cleanup function that stops the interval when called
+ */
+function setIntervalCallback(callback, interval) {
+    const timerId = setInterval(callback, interval);
+    return () => clearInterval(timerId);
+}
+
+/**
+ * Pauses execution for a specified duration.
+ *
+ * @param milliseconds - The duration to sleep in milliseconds
+ * @returns A promise that resolves after the specified duration
+ */
+function sleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+exports.createClock = createClock;
+exports.createTimer = createTimer;
+exports.normalizeToBaseTimeWindow = normalizeToBaseTimeWindow;
+exports.setIntervalCallback = setIntervalCallback;
+exports.sleep = sleep;
+//# sourceMappingURL=index.cjs.js.map

package/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":["../../../../libs/utils/time/src/create-clock.ts","../../../../libs/utils/time/src/create-timer.ts","../../../../libs/utils/time/src/normalize-to-base-time-window.ts","../../../../libs/utils/time/src/set-interval-callback.ts","../../../../libs/utils/time/src/sleep.ts"],"sourcesContent":[null,null,null,null,null],"names":[],"mappings":"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"}

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './create-clock';
+export * from './create-timer';
+export * from './normalize-to-base-time-window';
+export * from './set-interval-callback';
+export * from './sleep';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../libs/utils/time/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iCAAiC,CAAA;AAC/C,cAAc,yBAAyB,CAAA;AACvC,cAAc,SAAS,CAAA"}

package/index.esm.js

@@ -0,0 +1,120 @@
+/**
+ * Creates an interval loop that invokes one or more subscribed callback functions
+ * at the specified internal (in milliseconds).
+ *
+ * Allows you to start or stop the interval loop, much like a stop watch.
+ * Allows you to unsubscribe callback functions.
+ *
+ * @param interval - Time in milliseconds between each callback invocation (default: 1000ms)
+ * @returns A Clock instance with start, stop, subscribe, and unsubscribe methods
+ */
+function createClock(interval = 1000) {
+    let clockId = null;
+    let subscribers = [];
+    const start = () => {
+        if (clockId === null) {
+            clockId = setInterval(() => {
+                const currentTime = new Date();
+                subscribers.forEach((subscriber) => subscriber(currentTime));
+            }, interval);
+        }
+    };
+    const stop = () => {
+        if (clockId !== null) {
+            clearInterval(clockId);
+            clockId = null;
+        }
+    };
+    const subscribe = (callback) => {
+        subscribers.push(callback);
+    };
+    const unsubscribe = (callback) => {
+        subscribers = subscribers.filter((subscriber) => subscriber !== callback);
+    };
+    return Object.freeze({ start, stop, subscribe, unsubscribe, interval });
+}
+
+/**
+ * Invokes callback function after the designated time has passed, much like a timer.
+ * Allows you to pause, resume, or reset the progress of time tracked.
+ *
+ * @param callback - The function to invoke after the delay
+ * @param delay - Time in milliseconds to wait until callback is invoked
+ * @returns A Timer instance with pause, resume, and reset methods
+ */
+function createTimer(callback, delay) {
+    let timerId = null;
+    let start = null;
+    let remaining = delay;
+    const pause = () => {
+        if (timerId !== null) {
+            clearTimeout(timerId);
+            const now = Date.now();
+            /* istanbul ignore else - start is always set when timerId is not null */
+            if (start !== null) {
+                remaining -= now - start;
+            }
+            timerId = null;
+        }
+    };
+    const resume = () => {
+        if (timerId === null) {
+            start = Date.now();
+            timerId = setTimeout(() => {
+                callback();
+                timerId = null;
+            }, remaining);
+        }
+    };
+    const reset = (newDelay = delay) => {
+        pause();
+        remaining = newDelay;
+        resume();
+    };
+    return Object.freeze({ pause, resume, reset });
+}
+
+/**
+ * Normalizes a given time to the nearest base time window.
+ *
+ * @param time - The Date object to normalize to the nearest time window
+ * @param baseTimeWindow - The size of the time window in minutes for normalization
+ * @returns A new Date object normalized to the start of the time window
+ */
+function normalizeToBaseTimeWindow(time, baseTimeWindow) {
+    if (!time || !(time instanceof Date) || isNaN(time.getTime())) {
+        throw new Error('Invalid time input');
+    }
+    if (baseTimeWindow <= 0) {
+        throw new Error('Base time window must be positive');
+    }
+    const timeInMs = time.getTime();
+    const windowInMs = baseTimeWindow * 60 * 1000;
+    const normalizedTimeInMs = Math.floor(timeInMs / windowInMs) * windowInMs;
+    return new Date(normalizedTimeInMs);
+}
+
+/**
+ * Creates a repeating interval that invokes a callback function at regular intervals.
+ *
+ * @param callback - The function to invoke at each interval
+ * @param interval - Time in milliseconds between each callback invocation
+ * @returns A cleanup function that stops the interval when called
+ */
+function setIntervalCallback(callback, interval) {
+    const timerId = setInterval(callback, interval);
+    return () => clearInterval(timerId);
+}
+
+/**
+ * Pauses execution for a specified duration.
+ *
+ * @param milliseconds - The duration to sleep in milliseconds
+ * @returns A promise that resolves after the specified duration
+ */
+function sleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export { createClock, createTimer, normalizeToBaseTimeWindow, setIntervalCallback, sleep };
+//# sourceMappingURL=index.esm.js.map

package/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../../../../libs/utils/time/src/create-clock.ts","../../../../libs/utils/time/src/create-timer.ts","../../../../libs/utils/time/src/normalize-to-base-time-window.ts","../../../../libs/utils/time/src/set-interval-callback.ts","../../../../libs/utils/time/src/sleep.ts"],"sourcesContent":[null,null,null,null,null],"names":[],"mappings":"AASA;;;;;;;;;AASG;AACG,SAAU,WAAW,CAAC,QAAQ,GAAG,IAAI,EAAA;IACzC,IAAI,OAAO,GAA0B,IAAI;IACzC,IAAI,WAAW,GAAoC,EAAE;IAErD,MAAM,KAAK,GAAG,MAAW;AACvB,QAAA,IAAI,OAAO,KAAK,IAAI,EAAE;AACpB,YAAA,OAAO,GAAG,WAAW,CAAC,MAAK;AACzB,gBAAA,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE;AAC9B,gBAAA,WAAW,CAAC,OAAO,CAAC,CAAC,UAAU,KAAK,UAAU,CAAC,WAAW,CAAC,CAAC;YAC9D,CAAC,EAAE,QAAQ,CAAC;QACd;AACF,IAAA,CAAC;IAED,MAAM,IAAI,GAAG,MAAW;AACtB,QAAA,IAAI,OAAO,KAAK,IAAI,EAAE;YACpB,aAAa,CAAC,OAAO,CAAC;YACtB,OAAO,GAAG,IAAI;QAChB;AACF,IAAA,CAAC;AAED,IAAA,MAAM,SAAS,GAAG,CAAC,QAAqC,KAAU;AAChE,QAAA,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC;AAC5B,IAAA,CAAC;AAED,IAAA,MAAM,WAAW,GAAG,CAAC,QAAqC,KAAU;AAClE,QAAA,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,UAAU,KAAK,UAAU,KAAK,QAAQ,CAAC;AAC3E,IAAA,CAAC;AAED,IAAA,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC;AACzE;;ACvCA;;;;;;;AAOG;AACG,SAAU,WAAW,CAAC,QAAoB,EAAE,KAAa,EAAA;IAC7D,IAAI,OAAO,GAA0B,IAAI;IACzC,IAAI,KAAK,GAAkB,IAAI;IAC/B,IAAI,SAAS,GAAW,KAAK;IAE7B,MAAM,KAAK,GAAG,MAAW;AACvB,QAAA,IAAI,OAAO,KAAK,IAAI,EAAE;YACpB,YAAY,CAAC,OAAO,CAAC;AACrB,YAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE;;AAEtB,YAAA,IAAI,KAAK,KAAK,IAAI,EAAE;AAClB,gBAAA,SAAS,IAAI,GAAG,GAAG,KAAK;YAC1B;YACA,OAAO,GAAG,IAAI;QAChB;AACF,IAAA,CAAC;IAED,MAAM,MAAM,GAAG,MAAW;AACxB,QAAA,IAAI,OAAO,KAAK,IAAI,EAAE;AACpB,YAAA,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE;AAClB,YAAA,OAAO,GAAG,UAAU,CAAC,MAAK;AACxB,gBAAA,QAAQ,EAAE;gBACV,OAAO,GAAG,IAAI;YAChB,CAAC,EAAE,SAAS,CAAC;QACf;AACF,IAAA,CAAC;AAED,IAAA,MAAM,KAAK,GAAG,CAAC,QAAA,GAAmB,KAAK,KAAU;AAC/C,QAAA,KAAK,EAAE;QACP,SAAS,GAAG,QAAQ;AACpB,QAAA,MAAM,EAAE;AACV,IAAA,CAAC;AAED,IAAA,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;AAChD;;ACnDA;;;;;;AAMG;AACG,SAAU,yBAAyB,CAAC,IAAU,EAAE,cAAsB,EAAA;AAC1E,IAAA,IAAI,CAAC,IAAI,IAAI,EAAE,IAAI,YAAY,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE;AAC7D,QAAA,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC;IACvC;AAEA,IAAA,IAAI,cAAc,IAAI,CAAC,EAAE;AACvB,QAAA,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC;IACtD;AAEA,IAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE;AAC/B,IAAA,MAAM,UAAU,GAAG,cAAc,GAAG,EAAE,GAAG,IAAI;AAC7C,IAAA,MAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC,GAAG,UAAU;AACzE,IAAA,OAAO,IAAI,IAAI,CAAC,kBAAkB,CAAC;AACrC;;ACpBA;;;;;;AAMG;AACG,SAAU,mBAAmB,CAAC,QAAoB,EAAE,QAAgB,EAAA;IACxE,MAAM,OAAO,GAAmB,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC;AAC/D,IAAA,OAAO,MAAY,aAAa,CAAC,OAAO,CAAC;AAC3C;;ACVA;;;;;AAKG;AACG,SAAU,KAAK,CAAC,YAAoB,EAAA;AACxC,IAAA,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,UAAU,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;AACpE;;;;"}

package/normalize-to-base-time-window.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalizes a given time to the nearest base time window.
+ *
+ * @param time - The Date object to normalize to the nearest time window
+ * @param baseTimeWindow - The size of the time window in minutes for normalization
+ * @returns A new Date object normalized to the start of the time window
+ */
+export declare function normalizeToBaseTimeWindow(time: Date, baseTimeWindow: number): Date;
+//# sourceMappingURL=normalize-to-base-time-window.d.ts.map

package/normalize-to-base-time-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-to-base-time-window.d.ts","sourceRoot":"","sources":["../../../../libs/utils/time/src/normalize-to-base-time-window.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAalF"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@hyperfrontend/time-utils",
+  "version": "0.0.1",
+  "description": "Functional time utilities for async operations, intervals, and time normalization.",
+  "license": "MIT",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "keywords": [
+    "timer",
+    "clock",
+    "interval",
+    "timeout",
+    "sleep",
+    "delay",
+    "pause",
+    "resume",
+    "time-window",
+    "time-normalization",
+    "async",
+    "promise",
+    "zero-dependencies",
+    "typescript",
+    "functional",
+    "immutable"
+  ],
+  "main": "./index.cjs.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AndrewRedican/hyperfrontend.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AndrewRedican/hyperfrontend/issues"
+  },
+  "homepage": "https://github.com/AndrewRedican/hyperfrontend#readme",
+  "author": {
+    "name": "andrew.redican.mejia@gmail.com",
+    "url": "https://hyperfrontend.dev"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.cjs.js"
+    },
+    "./bundle": {
+      "import": "./bundle/index.iife.min.js",
+      "require": "./bundle/index.iife.min.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "types": "./index.d.ts",
+  "unpkg": "./bundle/index.umd.min.js",
+  "jsdelivr": "./bundle/index.umd.min.js"
+}

package/set-interval-callback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a repeating interval that invokes a callback function at regular intervals.
+ *
+ * @param callback - The function to invoke at each interval
+ * @param interval - Time in milliseconds between each callback invocation
+ * @returns A cleanup function that stops the interval when called
+ */
+export declare function setIntervalCallback(callback: () => void, interval: number): () => void;
+//# sourceMappingURL=set-interval-callback.d.ts.map

package/set-interval-callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-interval-callback.d.ts","sourceRoot":"","sources":["../../../../libs/utils/time/src/set-interval-callback.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,IAAI,CAGtF"}

package/sleep.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pauses execution for a specified duration.
+ *
+ * @param milliseconds - The duration to sleep in milliseconds
+ * @returns A promise that resolves after the specified duration
+ */
+export declare function sleep(milliseconds: number): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../../libs/utils/time/src/sleep.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzD"}