@kyo-services/schedulewise 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Timed Job
+
+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,194 @@
+# ScheduleWise
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0.0-blue.svg)](https://www.typescriptlang.org/)
+[![Node Version](https://img.shields.io/node/v/schedulewise)](https://nodejs.org/)
+[![Browser Support](https://img.shields.io/badge/browser-Chrome%20%7C%20Firefox%20%7C%20Safari%20%7C%20Edge-lightgrey)](https://browsersl.ist)
+
+A smart and efficient task scheduler for managing periodic jobs with precision timing and intelligent scheduling in both browser and Node.js environments. Built with modern TypeScript features and following best practices for reliable task scheduling.
+
+## 🚀 Features
+
+- **Singleton Pattern**: Ensures single scheduler instance across your application
+- **Type-Safe**: Full TypeScript support with type definitions
+- **Flexible Scheduling**: Custom intervals and immediate execution options
+- **Task Management**: Enable, disable, or remove tasks on demand
+- **Execution History**: Track task execution count and timestamps
+- **Zero Dependencies**: No external runtime dependencies
+- **Well Tested**: Comprehensive test coverage
+
+## 📦 Installation
+
+```bash
+npm install @kyo-services/schedulewise
+```
+
+## 🔧 Usage
+
+### Basic Task Scheduling
+
+```typescript
+import sw from '@kyo-services/schedulewise';
+
+// Create a periodic task
+const task = sw.scheduleTask(
+  (currentTime: Date, executionCount: number) => {
+    console.log(`Task executed at ${currentTime}, count: ${executionCount}`);
+  },
+  {
+    interval: 1000, // Run every second
+    name: 'logTask', // Optional task identifier
+    immediate: true // Run immediately when created
+  }
+);
+```
+
+### One-Time Task
+
+```typescript
+sw.scheduleTask(
+  () => {
+    console.log('This task runs only once after 5 seconds');
+  },
+  {
+    interval: 5000,
+    once: true
+  }
+);
+```
+
+### Task Management
+
+```typescript
+// Find task by name or ID
+const task = sw.findTask('logTask');
+
+// Disable task
+task?.disable();
+
+// Enable task
+task?.enable();
+
+// Update task configuration
+task?.update({
+  interval: 2000,
+  immediate: false
+});
+
+// Remove specific task
+task?.remove();
+// or
+sw.removeTask('logTask');
+
+// Remove all tasks
+sw.clearAllTasks();
+```
+
+## 📚 API Reference
+
+### TaskOptions
+
+```typescript
+interface TaskOptions {
+  interval: number;    // Interval in milliseconds
+  name?: string;      // Optional task identifier
+  immediate?: boolean; // Run immediately when created
+  once?: boolean;     // Run only once
+}
+```
+
+### Task Methods
+
+| Method | Description |
+|--------|-------------|
+| `disable()` | Temporarily disables the task |
+| `enable()` | Re-enables a disabled task |
+| `update(options)` | Updates task configuration |
+| `remove()` | Removes the task from scheduler |
+
+### Task Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `id` | `number` | Unique task identifier |
+| `name` | `string \| undefined` | Optional task name |
+| `lastExecutionTime` | `Date` | Last execution timestamp |
+| `executionCount` | `number` | Number of executions |
+| `isEnabled` | `boolean` | Current enabled status |
+
+### Scheduler Methods
+
+| Method | Description |
+|--------|-------------|
+| `scheduleTask(callback, options)` | Creates a new task |
+| `findTask(identifier)` | Finds task by ID or name |
+| `removeTask(identifier)` | Removes a specific task |
+| `clearAllTasks()` | Removes all tasks |
+| `getAllTasks()` | Gets all scheduled tasks |
+
+## 🧪 Testing
+
+```bash
+# Run tests
+npm test
+
+# Run tests with coverage
+npm test -- --coverage
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes using conventional commits (`git commit -m 'feat: add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## ⚡ Best Practices
+
+1. **Task Naming**: Use descriptive names for better task management
+```typescript
+sw.scheduleTask(sendEmail, { name: 'dailyNewsletterTask' });
+```
+
+2. **Error Handling**: Always handle task errors
+```typescript
+sw.scheduleTask(async () => {
+  try {
+    await riskyOperation();
+  } catch (error) {
+    console.error('Task failed:', error);
+  }
+}, { interval: 1000 });
+```
+
+3. **Resource Cleanup**: Remove tasks when no longer needed
+```typescript
+// In component unmount or cleanup
+task.remove();
+// or for all tasks
+sw.clearAllTasks();
+```
+
+4. **Interval Selection**: Choose appropriate intervals
+```typescript
+// Good: Clear intention
+const MINUTE = 60 * 1000;
+sw.scheduleTask(task, { interval: 5 * MINUTE });
+
+// Avoid: Magic numbers
+sw.scheduleTask(task, { interval: 300000 });
+```
+
+5. **Type Safety**: Leverage TypeScript types
+```typescript
+import type { TaskCallback, TaskOptions } from '@kyo-services/schedulewise';
+
+const callback: TaskCallback = (time: Date, count: number) => {
+  // Type-safe callback
+};
+```

package/dist/Task.d.ts

@@ -0,0 +1,74 @@
+import { TaskCallback } from './types';
+import { TaskScheduler } from './TaskScheduler';
+/**
+ * Represents a scheduled task in the system
+ * @class Task
+ */
+export declare class Task {
+    readonly name: string | undefined;
+    readonly id: number;
+    private callback;
+    private interval;
+    private executeImmediately;
+    private isOneTime;
+    private scheduler;
+    lastExecutionTime: Date;
+    executionCount: number;
+    isEnabled: boolean;
+    /**
+     * Creates a new Task instance
+     * @param {TaskScheduler} scheduler - Reference to the scheduler instance
+     * @param {string} [name] - Optional name to identify the task
+     * @param {number} id - Unique identifier for the task
+     * @param {TaskCallback} callback - Function to be executed
+     * @param {number} interval - Time interval in milliseconds between executions
+     * @param {boolean} executeImmediately - Whether to execute immediately
+     * @param {boolean} isOneTime - Whether to execute only once
+     */
+    constructor(scheduler: TaskScheduler, name: string | undefined, id: number, callback: TaskCallback, interval: number, executeImmediately: boolean, isOneTime: boolean);
+    /**
+     * Executes the task callback
+     * @param {Date} currentTime - Current timestamp
+     */
+    execute(currentTime: Date): void;
+    /**
+     * Enables the task
+     * @returns {Task} The task instance for chaining
+     */
+    enable(): Task;
+    /**
+     * Disables the task
+     * @returns {Task} The task instance for chaining
+     */
+    disable(): Task;
+    /**
+     * Updates the task configuration
+     * @param {TaskOptions} options - New configuration options
+     * @param {TaskCallback} [newCallback] - Optional new callback function
+     * @returns {Task} The task instance for chaining
+     */
+    update(options: {
+        interval: number;
+        immediate?: boolean;
+    }, newCallback?: TaskCallback): Task;
+    /**
+     * Removes the task from the scheduler
+     */
+    remove(): void;
+    /**
+     * Gets the task's interval
+     * @returns {number} The interval in milliseconds
+     */
+    getInterval(): number;
+    /**
+     * Checks if the task is ready to execute
+     * @param {number} elapsedTime - Time elapsed since last execution
+     * @returns {boolean} Whether the task should execute
+     */
+    shouldExecute(elapsedTime: number): boolean;
+    /**
+     * Checks if the task should be removed after execution
+     * @returns {boolean} Whether the task is one-time
+     */
+    shouldRemove(): boolean;
+}

package/dist/Task.js

@@ -0,0 +1,105 @@
+/**
+ * Represents a scheduled task in the system
+ * @class Task
+ */
+export class Task {
+    name;
+    id;
+    callback;
+    interval;
+    executeImmediately;
+    isOneTime;
+    scheduler;
+    lastExecutionTime;
+    executionCount;
+    isEnabled;
+    /**
+     * Creates a new Task instance
+     * @param {TaskScheduler} scheduler - Reference to the scheduler instance
+     * @param {string} [name] - Optional name to identify the task
+     * @param {number} id - Unique identifier for the task
+     * @param {TaskCallback} callback - Function to be executed
+     * @param {number} interval - Time interval in milliseconds between executions
+     * @param {boolean} executeImmediately - Whether to execute immediately
+     * @param {boolean} isOneTime - Whether to execute only once
+     */
+    constructor(scheduler, name, id, callback, interval, executeImmediately, isOneTime) {
+        this.name = name;
+        this.id = id;
+        this.callback = callback;
+        this.interval = interval;
+        this.executeImmediately = executeImmediately;
+        this.isOneTime = isOneTime;
+        this.scheduler = scheduler;
+        this.executionCount = 0;
+        this.isEnabled = true;
+        this.lastExecutionTime = new Date(0);
+    }
+    /**
+     * Executes the task callback
+     * @param {Date} currentTime - Current timestamp
+     */
+    execute(currentTime) {
+        this.callback(currentTime, this.executionCount + 1);
+        this.lastExecutionTime = currentTime;
+        this.executionCount++;
+    }
+    /**
+     * Enables the task
+     * @returns {Task} The task instance for chaining
+     */
+    enable() {
+        this.isEnabled = true;
+        return this;
+    }
+    /**
+     * Disables the task
+     * @returns {Task} The task instance for chaining
+     */
+    disable() {
+        this.isEnabled = false;
+        return this;
+    }
+    /**
+     * Updates the task configuration
+     * @param {TaskOptions} options - New configuration options
+     * @param {TaskCallback} [newCallback] - Optional new callback function
+     * @returns {Task} The task instance for chaining
+     */
+    update(options, newCallback) {
+        this.interval = options.interval;
+        this.executeImmediately = options.immediate || false;
+        if (newCallback)
+            this.callback = newCallback;
+        return this;
+    }
+    /**
+     * Removes the task from the scheduler
+     */
+    remove() {
+        this.scheduler.removeTask(this.id);
+    }
+    /**
+     * Gets the task's interval
+     * @returns {number} The interval in milliseconds
+     */
+    getInterval() {
+        return this.interval;
+    }
+    /**
+     * Checks if the task is ready to execute
+     * @param {number} elapsedTime - Time elapsed since last execution
+     * @returns {boolean} Whether the task should execute
+     */
+    shouldExecute(elapsedTime) {
+        return elapsedTime >= this.interval && this.isEnabled;
+    }
+    /**
+     * Checks if the task should be removed after execution
+     * @returns {boolean} Whether the task is one-time
+     */
+    shouldRemove() {
+        return this.isOneTime;
+    }
+}
+//# sourceMappingURL=Task.js.map

package/dist/Task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Task.js","sourceRoot":"","sources":["../src/Task.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,OAAO,IAAI;IAkBO;IACA;IACR;IACA;IACA;IACA;IAtBJ,SAAS,CAAgB;IAC1B,iBAAiB,CAAO;IACxB,cAAc,CAAS;IACvB,SAAS,CAAU;IAE1B;;;;;;;;;OASG;IACH,YACI,SAAwB,EACR,IAAwB,EACxB,EAAU,EAClB,QAAsB,EACtB,QAAgB,EAChB,kBAA2B,EAC3B,SAAkB;QALV,SAAI,GAAJ,IAAI,CAAoB;QACxB,OAAE,GAAF,EAAE,CAAQ;QAClB,aAAQ,GAAR,QAAQ,CAAc;QACtB,aAAQ,GAAR,QAAQ,CAAQ;QAChB,uBAAkB,GAAlB,kBAAkB,CAAS;QAC3B,cAAS,GAAT,SAAS,CAAS;QAE1B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,iBAAiB,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,OAAO,CAAC,WAAiB;QAC5B,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC;QACrC,IAAI,CAAC,cAAc,EAAE,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACI,MAAM;QACT,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACI,OAAO;QACV,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,OAAkD,EAAE,WAA0B;QACxF,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC;QACrD,IAAI,WAAW;YAAE,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC;QAC7C,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;OAEG;IACI,MAAM;QACT,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACvC,CAAC;IAED;;;OAGG;IACI,WAAW;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,WAAmB;QACpC,OAAO,WAAW,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACI,YAAY;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;CACJ"}

package/dist/TaskScheduler.d.ts

@@ -0,0 +1,55 @@
+import { Task } from './Task';
+import { TaskCallback, TaskOptions } from './types';
+/**
+ * A singleton class that manages scheduled tasks in the system
+ * @class TaskScheduler
+ */
+export declare class TaskScheduler {
+    private static instance;
+    private currentTimestamp;
+    private scheduledTasks;
+    private schedulerInterval;
+    private constructor();
+    /**
+     * Gets the singleton instance of TaskScheduler
+     * @returns {TaskScheduler} The singleton instance
+     */
+    static getInstance(): TaskScheduler;
+    /**
+     * Finds a task by its identifier (id or name)
+     * @param {number | string} identifier - The task's ID or name
+     * @returns {Task | undefined} The found task or undefined
+     */
+    findTask(identifier: number | string): Task | undefined;
+    /**
+     * Gets all scheduled tasks in the system
+     * @returns {Task[]} Array of all scheduled tasks
+     */
+    getAllTasks(): Task[];
+    /**
+     * Creates and schedules a new task
+     * @param {TaskCallback} callback - Function to be executed
+     * @param {TaskOptions} options - Configuration options for the task
+     * @returns {Task} The created task instance
+     */
+    scheduleTask(callback: TaskCallback, options: TaskOptions): Task;
+    /**
+     * Removes a task from the scheduler
+     * @param {number | string} identifier - The task's ID or name
+     */
+    removeTask(identifier: number | string): void;
+    /**
+     * Removes all tasks and stops the scheduler
+     */
+    clearAllTasks(): void;
+    /**
+     * Updates current timestamp and processes tasks
+     * @internal For testing purposes
+     */
+    processTasksNow(): void;
+    /**
+     * Starts the task processor that executes scheduled tasks
+     * @private
+     */
+    private startTaskProcessor;
+}

package/dist/TaskScheduler.js

@@ -0,0 +1,110 @@
+import { Task } from './Task';
+/**
+ * A singleton class that manages scheduled tasks in the system
+ * @class TaskScheduler
+ */
+export class TaskScheduler {
+    static instance;
+    currentTimestamp;
+    scheduledTasks = new Map();
+    schedulerInterval = null;
+    constructor() {
+        this.currentTimestamp = new Date();
+        this.startTaskProcessor();
+    }
+    /**
+     * Gets the singleton instance of TaskScheduler
+     * @returns {TaskScheduler} The singleton instance
+     */
+    static getInstance() {
+        if (!TaskScheduler.instance)
+            TaskScheduler.instance = new TaskScheduler();
+        return TaskScheduler.instance;
+    }
+    /**
+     * Finds a task by its identifier (id or name)
+     * @param {number | string} identifier - The task's ID or name
+     * @returns {Task | undefined} The found task or undefined
+     */
+    findTask(identifier) {
+        return this.scheduledTasks.get(identifier);
+    }
+    /**
+     * Gets all scheduled tasks in the system
+     * @returns {Task[]} Array of all scheduled tasks
+     */
+    getAllTasks() {
+        return Array.from(this.scheduledTasks.values());
+    }
+    /**
+     * Creates and schedules a new task
+     * @param {TaskCallback} callback - Function to be executed
+     * @param {TaskOptions} options - Configuration options for the task
+     * @returns {Task} The created task instance
+     */
+    scheduleTask(callback, options) {
+        const taskId = Math.floor(Math.random() * 1000000);
+        const task = new Task(this, options.name, taskId, callback, options.interval, false, options.once || false);
+        this.scheduledTasks.set(taskId, task);
+        if (options.name)
+            this.scheduledTasks.set(options.name, task);
+        if (options.immediate) {
+            task.execute(this.currentTimestamp);
+            task.lastExecutionTime = this.currentTimestamp;
+        }
+        return task;
+    }
+    /**
+     * Removes a task from the scheduler
+     * @param {number | string} identifier - The task's ID or name
+     */
+    removeTask(identifier) {
+        const task = this.findTask(identifier);
+        if (!task)
+            return;
+        this.scheduledTasks.delete(task.id);
+        if (task.name)
+            this.scheduledTasks.delete(task.name);
+    }
+    /**
+     * Removes all tasks and stops the scheduler
+     */
+    clearAllTasks() {
+        if (this.schedulerInterval) {
+            clearInterval(this.schedulerInterval);
+            this.schedulerInterval = null;
+        }
+        this.scheduledTasks.clear();
+    }
+    /**
+     * Updates current timestamp and processes tasks
+     * @internal For testing purposes
+     */
+    processTasksNow() {
+        const previousTimestamp = this.currentTimestamp;
+        this.currentTimestamp = new Date();
+        for (const task of this.scheduledTasks.values()) {
+            const elapsedTime = task.getInterval(); // Bir interval süresi geçmiş varsayalım
+            const shouldRun = task.shouldExecute(elapsedTime) &&
+                task.lastExecutionTime.getTime() <= previousTimestamp.getTime();
+            if (!shouldRun)
+                continue;
+            task.execute(this.currentTimestamp);
+            if (task.shouldRemove()) {
+                this.removeTask(task.id);
+            }
+        }
+    }
+    /**
+     * Starts the task processor that executes scheduled tasks
+     * @private
+     */
+    startTaskProcessor() {
+        if (this.schedulerInterval)
+            clearInterval(this.schedulerInterval);
+        this.schedulerInterval = setInterval(() => {
+            this.processTasksNow();
+        }, 100);
+    }
+}
+//# sourceMappingURL=TaskScheduler.js.map

package/dist/TaskScheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskScheduler.js","sourceRoot":"","sources":["../src/TaskScheduler.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { TaskScheduler } from './TaskScheduler';
+export { TaskCallback, TaskOptions } from './types';
+declare const _default: TaskScheduler;
+export default _default;

package/dist/index.js

@@ -0,0 +1,3 @@
+import { TaskScheduler } from './TaskScheduler';
+export default TaskScheduler.getInstance();
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,eAAe,aAAa,CAAC,WAAW,EAAE,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Callback function type for scheduled tasks
+ * @callback TaskCallback
+ * @param {Date} [executionTime] - Timestamp when the task was executed
+ * @param {number} [executionCount] - Number of times the task has been executed
+ * @returns {void}
+ */
+export type TaskCallback = (executionTime?: Date, executionCount?: number) => void;
+/**
+ * Configuration options for creating a scheduled task
+ * @typedef {Object} TaskOptions
+ * @property {string} [name] - Optional name to identify the task
+ * @property {number} interval - Time interval in milliseconds between executions
+ * @property {boolean} [immediate] - Whether to execute the task immediately upon creation
+ * @property {boolean} [once] - Whether the task should only execute once
+ */
+export type TaskOptions = {
+    name?: string;
+    interval: number;
+    immediate?: boolean;
+    once?: boolean;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "@kyo-services/schedulewise",
+	"version": "1.0.0",
+	"type": "module",
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"description": "A smart and efficient task scheduler for managing periodic jobs with precision timing and intelligent scheduling in both browser and Node.js environments",
+	"main": "dist/main.js",
+	"types": "dist/main.d.ts",
+	"scripts": {
+		"build": "tsc --project tsconfig.json",
+		"test": "jest --config jest.config.cjs",
+		"test:watch": "jest --config jest.config.cjs --watch",
+		"prepare": "husky install && npm run build",
+		"lint": "eslint . --ext .ts",
+		"lint:fix": "eslint . --ext .ts --fix",
+		"prepublishOnly": "npm run build && npm test"
+	},
+	"keywords": [
+		"task",
+		"scheduler",
+		"job",
+		"periodic",
+		"interval",
+		"timer",
+		"cron",
+		"typescript"
+	],
+	"author": "",
+	"license": "MIT",
+	"devDependencies": {
+		"@commitlint/cli": "^19.8.1",
+		"@commitlint/config-conventional": "^19.8.1",
+		"@types/jest": "^29.5.14",
+		"@typescript-eslint/eslint-plugin": "^8.38.0",
+		"@typescript-eslint/parser": "^8.38.0",
+		"eslint": "^9.32.0",
+		"husky": "^9.1.7",
+		"jest": "^29.7.0",
+		"lint-staged": "^16.1.2",
+		"ts-jest": "^29.4.0",
+		"typescript": "^5.0.0",
+		"typescript-eslint": "^8.38.0"
+	},
+	"files": [
+		"dist/*.js",
+		"dist/*.d.ts",
+		"dist/*.map",
+		"src"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/kyo-services/schedulewise.git"
+	},
+	"bugs": {
+		"url": "https://github.com/kyo-services/schedulewise/issues"
+	},
+	"homepage": "https://github.com/kyo-services/schedulewise#readme",
+	"lint-staged": {
+		"*.ts": [
+			"eslint --fix",
+			"jest --findRelatedTests"
+		]
+	}
+}

package/src/Task.ts

@@ -0,0 +1,111 @@
+import { TaskCallback } from './types';
+import { TaskScheduler } from './TaskScheduler';
+
+/**
+ * Represents a scheduled task in the system
+ * @class Task
+ */
+export class Task {
+    private scheduler: TaskScheduler;
+    public lastExecutionTime: Date;
+    public executionCount: number;
+    public isEnabled: boolean;
+
+    /**
+     * Creates a new Task instance
+     * @param {TaskScheduler} scheduler - Reference to the scheduler instance
+     * @param {string} [name] - Optional name to identify the task
+     * @param {number} id - Unique identifier for the task
+     * @param {TaskCallback} callback - Function to be executed
+     * @param {number} interval - Time interval in milliseconds between executions
+     * @param {boolean} executeImmediately - Whether to execute immediately
+     * @param {boolean} isOneTime - Whether to execute only once
+     */
+    constructor(
+        scheduler: TaskScheduler,
+        public readonly name: string | undefined,
+        public readonly id: number,
+        private callback: TaskCallback,
+        private interval: number,
+        private executeImmediately: boolean,
+        private isOneTime: boolean
+    ) {
+        this.scheduler = scheduler;
+        this.executionCount = 0;
+        this.isEnabled = true;
+        this.lastExecutionTime = new Date(0);
+    }
+
+    /**
+     * Executes the task callback
+     * @param {Date} currentTime - Current timestamp
+     */
+    public execute(currentTime: Date): void {
+        this.callback(currentTime, this.executionCount + 1);
+        this.lastExecutionTime = currentTime;
+        this.executionCount++;
+    }
+
+    /**
+     * Enables the task
+     * @returns {Task} The task instance for chaining
+     */
+    public enable(): Task {
+        this.isEnabled = true;
+        return this;
+    }
+
+    /**
+     * Disables the task
+     * @returns {Task} The task instance for chaining
+     */
+    public disable(): Task {
+        this.isEnabled = false;
+        return this;
+    }
+
+    /**
+     * Updates the task configuration
+     * @param {TaskOptions} options - New configuration options
+     * @param {TaskCallback} [newCallback] - Optional new callback function
+     * @returns {Task} The task instance for chaining
+     */
+    public update(options: { interval: number, immediate?: boolean }, newCallback?: TaskCallback): Task {
+        this.interval = options.interval;
+        this.executeImmediately = options.immediate || false;
+        if (newCallback) this.callback = newCallback;
+        return this;
+    }
+
+    /**
+     * Removes the task from the scheduler
+     */
+    public remove(): void {
+        this.scheduler.removeTask(this.id);
+    }
+
+    /**
+     * Gets the task's interval
+     * @returns {number} The interval in milliseconds
+     */
+    public getInterval(): number {
+        return this.interval;
+    }
+
+    /**
+     * Checks if the task is ready to execute
+     * @param {number} elapsedTime - Time elapsed since last execution
+     * @returns {boolean} Whether the task should execute
+     */
+    public shouldExecute(elapsedTime: number): boolean {
+        return elapsedTime >= this.interval && this.isEnabled;
+    }
+
+    /**
+     * Checks if the task should be removed after execution
+     * @returns {boolean} Whether the task is one-time
+     */
+    public shouldRemove(): boolean {
+        return this.isOneTime;
+    }
+}

package/src/TaskScheduler.ts

@@ -0,0 +1,130 @@
+import { Task } from './Task';
+import { TaskCallback, TaskOptions } from './types';
+
+/**
+ * A singleton class that manages scheduled tasks in the system
+ * @class TaskScheduler
+ */
+export class TaskScheduler {
+    private static instance: TaskScheduler;
+    private currentTimestamp: Date;
+    private scheduledTasks: Map<number | string, Task> = new Map();
+    private schedulerInterval: ReturnType<typeof setInterval> | null = null;
+
+    private constructor() {
+        this.currentTimestamp = new Date();
+        this.startTaskProcessor();
+    }
+
+    /**
+     * Gets the singleton instance of TaskScheduler
+     * @returns {TaskScheduler} The singleton instance
+     */
+    public static getInstance(): TaskScheduler {
+        if (!TaskScheduler.instance) TaskScheduler.instance = new TaskScheduler();
+        return TaskScheduler.instance;
+    }
+
+    /**
+     * Finds a task by its identifier (id or name)
+     * @param {number | string} identifier - The task's ID or name
+     * @returns {Task | undefined} The found task or undefined
+     */
+    public findTask(identifier: number | string): Task | undefined {
+        return this.scheduledTasks.get(identifier);
+    }
+
+    /**
+     * Gets all scheduled tasks in the system
+     * @returns {Task[]} Array of all scheduled tasks
+     */
+    public getAllTasks(): Task[] {
+        return Array.from(this.scheduledTasks.values());
+    }
+
+    /**
+     * Creates and schedules a new task
+     * @param {TaskCallback} callback - Function to be executed
+     * @param {TaskOptions} options - Configuration options for the task
+     * @returns {Task} The created task instance
+     */
+    public scheduleTask(callback: TaskCallback, options: TaskOptions): Task {
+        const taskId = Math.floor(Math.random() * 1000000);
+        const task = new Task(
+            this,
+            options.name,
+            taskId,
+            callback,
+            options.interval,
+            false,
+            options.once || false
+        );
+
+        this.scheduledTasks.set(taskId, task);
+        if (options.name) this.scheduledTasks.set(options.name, task);
+
+        if (options.immediate) {
+            task.execute(this.currentTimestamp);
+            task.lastExecutionTime = this.currentTimestamp;
+        }
+
+        return task;
+    }
+
+    /**
+     * Removes a task from the scheduler
+     * @param {number | string} identifier - The task's ID or name
+     */
+    public removeTask(identifier: number | string): void {
+        const task = this.findTask(identifier);
+        if (!task) return;
+
+        this.scheduledTasks.delete(task.id);
+        if (task.name) this.scheduledTasks.delete(task.name);
+    }
+
+    /**
+     * Removes all tasks and stops the scheduler
+     */
+    public clearAllTasks(): void {
+        if (this.schedulerInterval) {
+            clearInterval(this.schedulerInterval);
+            this.schedulerInterval = null;
+        }
+        this.scheduledTasks.clear();
+    }
+
+    /**
+     * Updates current timestamp and processes tasks
+     * @internal For testing purposes
+     */
+    public processTasksNow(): void {
+        const previousTimestamp = this.currentTimestamp;
+        this.currentTimestamp = new Date();
+        
+        for (const task of this.scheduledTasks.values()) {
+            const elapsedTime = task.getInterval(); // Bir interval süresi geçmiş varsayalım
+            const shouldRun = task.shouldExecute(elapsedTime) && 
+                            task.lastExecutionTime.getTime() <= previousTimestamp.getTime();
+
+            if (!shouldRun) continue;
+
+            task.execute(this.currentTimestamp);
+            if (task.shouldRemove()) {
+                this.removeTask(task.id);
+            }
+        }
+    }
+
+    /**
+     * Starts the task processor that executes scheduled tasks
+     * @private
+     */
+    private startTaskProcessor(): void {
+        if (this.schedulerInterval) clearInterval(this.schedulerInterval);
+        
+        this.schedulerInterval = setInterval(() => {
+            this.processTasksNow();
+        }, 100);
+    }
+}

package/src/__tests__/TaskCreation.test.ts

@@ -0,0 +1,46 @@
+import { setupTest, cleanupTest } from "./testUtils";
+import { TaskScheduler } from "../TaskScheduler";
+
+describe("Task Creation", () => {
+	let scheduler: TaskScheduler;
+
+	beforeEach(() => {
+		scheduler = setupTest();
+	});
+
+	afterEach(() => {
+		cleanupTest();
+	});
+
+	it("should create a task with basic configuration", () => {
+		const callback = jest.fn();
+		const task = scheduler.scheduleTask(callback, { interval: 1000 });
+
+		expect(task).toBeDefined();
+		expect(task.getInterval()).toBe(1000);
+		expect(task.isEnabled).toBe(true);
+		expect(task.executionCount).toBe(0);
+	});
+
+	it("should create a task with immediate execution", () => {
+		const callback = jest.fn();
+		const task = scheduler.scheduleTask(callback, {
+			interval: 1000,
+			immediate: true,
+		});
+
+		expect(callback).toHaveBeenCalledTimes(1);
+		expect(task.executionCount).toBe(1);
+	});
+
+	it("should create a task with a name", () => {
+		const callback = jest.fn();
+		const task = scheduler.scheduleTask(callback, {
+			interval: 1000,
+			name: "testTask",
+		});
+
+		expect(task.name).toBe("testTask");
+		expect(scheduler.findTask("testTask")).toBe(task);
+	});
+});

package/src/__tests__/TaskExecution.test.ts

@@ -0,0 +1,69 @@
+import { setupTest, cleanupTest } from "./testUtils";
+import { TaskScheduler } from "../TaskScheduler";
+
+describe("Task Execution", () => {
+	let scheduler: TaskScheduler;
+
+	beforeEach(() => {
+		scheduler = setupTest();
+	});
+
+	afterEach(() => {
+		cleanupTest();
+	});
+
+	it("should execute task at regular intervals", () => {
+		const callback = jest.fn();
+		scheduler.scheduleTask(callback, { interval: 1000 });
+
+		// İlk çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		// İkinci çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(2);
+
+		// Üçüncü çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(3);
+	});
+
+	it("should execute task only once when configured", () => {
+		const callback = jest.fn();
+		scheduler.scheduleTask(callback, {
+			interval: 1000,
+			once: true,
+		});
+
+		// İlk çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		// İkinci çalıştırma - çağrılmamalı
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		// Üçüncü çalıştırma - çağrılmamalı
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+	});
+
+	it("should not execute disabled tasks", () => {
+		const callback = jest.fn();
+		const task = scheduler.scheduleTask(callback, { interval: 1000 });
+		task.disable();
+
+		// İlk çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(0);
+
+		// İkinci çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(0);
+
+		// Üçüncü çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(0);
+	});
+});

package/src/__tests__/TaskManagement.test.ts

@@ -0,0 +1,75 @@
+import { setupTest, cleanupTest } from "./testUtils";
+import { TaskScheduler } from "../TaskScheduler";
+
+describe("Task Management", () => {
+	let scheduler: TaskScheduler;
+
+	beforeEach(() => {
+		scheduler = setupTest();
+	});
+
+	afterEach(() => {
+		cleanupTest();
+	});
+
+	it("should enable and disable tasks", () => {
+		const callback = jest.fn();
+		const task = scheduler.scheduleTask(callback, { interval: 1000 });
+
+		// İlk çalıştırma - aktif
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		task.disable();
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		task.enable();
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(2);
+	});
+
+	it("should remove tasks", () => {
+		const callback = jest.fn();
+		const task = scheduler.scheduleTask(callback, {
+			interval: 1000,
+			name: "testTask",
+		});
+
+		// İlk çalıştırma
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		task.remove();
+
+		expect(scheduler.findTask(task.id)).toBeUndefined();
+		expect(scheduler.findTask("testTask")).toBeUndefined();
+
+		// Task silindiği için çağrılmamalı
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		scheduler.processTasksNow();
+		expect(callback).toHaveBeenCalledTimes(1);
+	});
+
+	it("should clear all tasks", () => {
+		const callback1 = jest.fn();
+		const callback2 = jest.fn();
+
+		scheduler.scheduleTask(callback1, { interval: 1000 });
+		scheduler.scheduleTask(callback2, { interval: 1000 });
+
+		scheduler.clearAllTasks();
+
+		// Tüm tasklar silindiği için çağrılmamalı
+		scheduler.processTasksNow();
+		expect(callback1).not.toHaveBeenCalled();
+
+		scheduler.processTasksNow();
+		expect(callback2).not.toHaveBeenCalled();
+
+		// Task listesi boş olmalı
+		expect(scheduler.getAllTasks()).toHaveLength(0);
+	});
+});

package/src/__tests__/testUtils.ts

@@ -0,0 +1,38 @@
+import { TaskScheduler } from "../TaskScheduler";
+
+let scheduler: TaskScheduler;
+let OriginalDate: DateConstructor;
+
+export const mockDate = (date: Date): void => {
+	OriginalDate = global.Date;
+	const MockDate = class extends OriginalDate {
+		constructor(...args: ConstructorParameters<typeof Date>) {
+			super(...args);
+			return date;
+		}
+		static now(): number {
+			return date.getTime();
+		}
+	} as unknown as DateConstructor;
+	global.Date = MockDate;
+	jest.useFakeTimers();
+};
+
+export const restoreDate = (): void => {
+	jest.useRealTimers();
+	global.Date = OriginalDate;
+};
+
+export const setupTest = (): TaskScheduler => {
+	const now = new Date();
+	mockDate(now);
+	scheduler = TaskScheduler.getInstance();
+	return scheduler;
+};
+
+export const cleanupTest = (): void => {
+	restoreDate();
+	if (scheduler) {
+		scheduler.clearAllTasks();
+	}
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+import { TaskScheduler } from './TaskScheduler';
+export { TaskCallback, TaskOptions } from './types';
+
+export default TaskScheduler.getInstance();

package/src/types.ts

@@ -0,0 +1,23 @@
+/**
+ * Callback function type for scheduled tasks
+ * @callback TaskCallback
+ * @param {Date} [executionTime] - Timestamp when the task was executed
+ * @param {number} [executionCount] - Number of times the task has been executed
+ * @returns {void}
+ */
+export type TaskCallback = (executionTime?: Date, executionCount?: number) => void;
+
+/**
+ * Configuration options for creating a scheduled task
+ * @typedef {Object} TaskOptions
+ * @property {string} [name] - Optional name to identify the task
+ * @property {number} interval - Time interval in milliseconds between executions
+ * @property {boolean} [immediate] - Whether to execute the task immediately upon creation
+ * @property {boolean} [once] - Whether the task should only execute once
+ */
+export type TaskOptions = {
+    name?: string;
+    interval: number;
+    immediate?: boolean;
+    once?: boolean;
+};