the-best-sort 1.0.0

package/LICENCE

@@ -0,0 +1,12 @@
+                     ОБЩЕСТВЕННАЯ ЛИЦЕНЗИЯ "УДАЧИ С ЭТИМ"
+        УСЛОВИЯ И ПОЛОЖЕНИЯ ДЛЯ КОПИРОВАНИЯ, РАСПРОСТРАНЕНИЯ И ИЗМЕНЕНИЯ
+
+0. Вы можете ДЕЛАТЬ ВСЁ, ЧТО ЗАХОТИТЕ до тех пор, пока ВЫ НЕ ОСТАВЛЯЕТЕ УЛИК
+ДЛЯ НАХОЖДЕНИЯ АВТОРА оригинального продукта, чтобы обвинить его или заставить
+взять на себя ответственность.
+
+НИ ПРИ КАКИХ ОБСТОЯТЕЛЬСТВАХ АВТОРЫ НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ЗА ПРЕТЕНЗИИ,
+УБЫТКИ ИЛИ ДРУГИЕ ОТВЕТСТВЕННОСТИ, ПОДНЯТЫЕ ВО ВРЕМЯ КОНТРАКТА И ВЫЗВАННЫЕ
+ПРЯМОЙ ИЛИ КОСВЕННОЙ СВЯЗЬЮ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
+
+Удачи, и храни тебя Господь.

package/README.md

@@ -0,0 +1,203 @@
+# The Best Sort
+
+A comprehensive TypeScript library for array visualization and asynchronous processing using powerful strategy  with advanced object-oriented programming patterns and design principles.
+
+## Overview
+
+The Best Sort is a production ready framework that demonstrates the application of multiple OOP design patterns, architectural principles, and advanced TypeScript features to visualize array element processing. The library implements a most powerful sort strategy.
+
+## Installation
+
+### Prerequisites
+
+- Node.js 18.0.0 or higher
+- npm or yarn
+
+### Setup
+
+Clone the repository and install dependencies:
+
+```sh
+npm install -D typescript @types/node
+```
+
+## Running the Library
+
+```sh
+npm install -D tsx
+npx tsx src/index.ts
+```
+
+### Manual Compilation
+
+```sh
+npx tsc src/index.ts --experimentalDecorators --emitDecoratorMetadata
+node the-best-sort.js
+```
+
+## Design Patterns
+
+The Best Sort implements multiple design patterns to create a robust and extensible framework, including singleton, factory, builder, facade, decorators, strategy, observer, command invoker and runner.
+
+
+## Core Components
+
+### VisualizableNumber
+
+A comparable number wrapper implementing the `IVisualizable` interface:
+
+```typescript
+const nums =.map(n => new VisualizableNumber(n));
+```
+
+
+### VisualizationContext
+
+Manages state and event notifications during visualization:
+
+```typescript
+const context = new VisualizationContext<VisualizableNumber>("Strategy Name");
+context.attach(observer);
+context.emitElementDisplayed(element, index, delay);
+```
+
+
+### Observers
+
+Track visualization events and collect metrics:
+
+```typescript
+const statsObserver = new StatisticsObserver<VisualizableNumber>();
+visualizer.addObserver(statsObserver);
+```
+
+
+### Configuration Management
+
+Control visualization behavior globally:
+
+```typescript
+ConfigurationManager.getInstance().updateConfig({
+  baseDelayMs: 100,
+  enableLogging: true,
+  showTimestamps: true,
+  colorize: true
+});
+```
+
+
+## Event Types
+
+The library emits the following event types during visualization:
+
+- `STARTED` - Visualization has started
+- `ELEMENT_DISPLAYED` - An array element was displayed
+- `COMPLETED` - Visualization has completed
+- `ERROR` - An error occurred during visualization
+
+## Performance Metrics
+
+`StatisticsObserver` collects the following metrics:
+
+```typescript
+interface VisualizationStatistics {
+  duration: number; // Total duration in milliseconds
+  displayedElements: number; // Number of elements displayed
+  totalDelay: number; // Sum of all delays
+  averageDelay: number; // Average delay per element
+  eventCounts: Map<EventType, number>; // Event counts by type
+}
+```
+
+
+## Architecture
+
+The library follows a layered architecture:
+
+1. **Core Domain** - `VisualizableNumber`, event types, configuration
+2. **Patterns Layer** - Decorators, strategies, factory implementations
+3. **Context Layer** - `VisualizationContext` managing state and notifications
+4. **Observer Layer** - Multiple observer implementations
+5. **Application Layer** - `ArrayVisualizer`, `CommandInvoker`, runners
+6. **Factory Layer** - Strategy and builder creation
+
+## TypeScript Features Used
+
+- Generics for type-safe implementations
+- Decorators for cross-cutting concerns
+- Abstract classes and interfaces for contracts
+- Union types and enums for type safety
+- Method decorators with property descriptors
+- Readonly types for immutability
+- Object destructuring and spreading
+
+## Extending the Library
+
+### Creating Custom Observers
+
+```typescript
+class CustomObserver<T extends IVisualizable> implements IObserver<T> {
+  update(event: VisualizationEvent<T>): void {
+    // Custom logic here
+  }
+}
+
+visualizer.addObserver(new CustomObserver());
+```
+
+
+### Creating Custom Commands
+
+```typescript
+class CustomCommand implements ICommand {
+  execute(): void {
+    // Custom command logic
+  }
+
+  getDescription(): string {
+    return "Custom command description";
+  }
+}
+
+invoker.enqueueCommand(new CustomCommand());
+```
+
+
+### Creating Custom Runners
+
+```typescript
+class CustomRunner<T extends IVisualizable>
+extends AbstractVisualizationRunner<T> {
+  
+  protected beforeRun(): void {
+    console.log("Before run");
+  }
+  
+  protected afterRun(): void {
+    console.log("After run");
+  }
+}
+
+const runner = new CustomRunner<VisualizableNumber>();
+runner.run(array, StrategyType.TIMEOUT_FOREACH);
+```
+
+## Requirements
+
+- TypeScript 4.7 or higher
+- Node.js 18.0.0 or higher
+- Decorator support enabled in `tsconfig.json`
+
+## Limitations
+
+- All timing is based on setTimeout, which may be affected by event loop congestion
+- Very large arrays (10,000+) may cause performance degradation
+- setTimeout precision is not guaranteed to be exact at sub-millisecond scales
+
+## Contributing
+
+Contributions are welcome. Please ensure all code follows the established patterns and includes appropriate type annotations.
+
+## Support
+
+For issues, questions, or feature requests, please open an issue in the repository.

package/dist/index.d.ts

@@ -0,0 +1,199 @@
+interface IVisualizable {
+    getValue(): number;
+    toString(): string;
+}
+interface IObserver<T> {
+    update(event: VisualizationEvent<T>): void;
+}
+interface ISubject<T> {
+    attach(observer: IObserver<T>): void;
+    detach(observer: IObserver<T>): void;
+    notify(event: VisualizationEvent<T>): void;
+}
+declare enum EventType {
+    STARTED = "STARTED",
+    ELEMENT_DISPLAYED = "ELEMENT_DISPLAYED",
+    COMPLETED = "COMPLETED",
+    ERROR = "ERROR"
+}
+interface VisualizationEvent<T> {
+    type: EventType;
+    element?: T;
+    index?: number;
+    timestamp: number;
+    delay?: number;
+    metadata?: Record<string, any>;
+}
+interface IVisualizationStrategy<T extends IVisualizable> {
+    visualize(array: T[], context: VisualizationContext<T>): void;
+    getName(): string;
+    getDescription(): string;
+}
+interface IVisualizationStrategyFactory<T extends IVisualizable> {
+    createStrategy(type: StrategyType): IVisualizationStrategy<T>;
+    registerStrategy(type: StrategyType, strategy: IVisualizationStrategy<T>): void;
+    listAvailableStrategies(): string[];
+}
+declare enum StrategyType {
+    TIMEOUT_FOREACH = "TIMEOUT_FOREACH"
+}
+interface VisualizationConfig {
+    baseDelayMs: number;
+    enableLogging: boolean;
+    logPrefix: string;
+    showTimestamps: boolean;
+    colorize: boolean;
+}
+declare class VisualizableNumber implements IVisualizable {
+    private readonly value;
+    constructor(value: number);
+    getValue(): number;
+    toString(): string;
+    toDetailedString(): string;
+}
+declare class ConfigurationManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): ConfigurationManager;
+    getConfig(): Readonly<VisualizationConfig>;
+    updateConfig(partial: Partial<VisualizationConfig>): void;
+    resetToDefaults(): void;
+}
+declare function Measure(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+declare function Log(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+declare function ValidateArray(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+declare class VisualizationContext<T extends IVisualizable> implements ISubject<T> {
+    private strategyName;
+    private observers;
+    private eventHistory;
+    private elementCount;
+    constructor(strategyName: string);
+    attach(observer: IObserver<T>): void;
+    detach(observer: IObserver<T>): void;
+    notify(event: VisualizationEvent<T>): void;
+    emitStarted(): void;
+    emitElementDisplayed(element: T, index: number, delay: number): void;
+    emitCompleted(): void;
+    emitError(error: Error): void;
+    getEventHistory(): VisualizationEvent<T>[];
+    getElementCount(): number;
+    getStrategyName(): string;
+}
+declare class ConsoleLoggingObserver<T extends IVisualizable> implements IObserver<T> {
+    private config;
+    update(event: VisualizationEvent<T>): void;
+}
+declare class StatisticsObserver<T extends IVisualizable> implements IObserver<T> {
+    private startTime;
+    private endTime;
+    private displayedElements;
+    private totalDelay;
+    private events;
+    update(event: VisualizationEvent<T>): void;
+    getStatistics(): VisualizationStatistics;
+    printStatistics(): void;
+    reset(): void;
+}
+interface VisualizationStatistics {
+    duration: number;
+    displayedElements: number;
+    totalDelay: number;
+    averageDelay: number;
+    eventCounts: Map<EventType, number>;
+}
+declare class HistoryObserver<T extends IVisualizable> implements IObserver<T> {
+    private history;
+    update(event: VisualizationEvent<T>): void;
+    getHistory(): Array<{
+        event: VisualizationEvent<T>;
+        formattedTime: string;
+    }>;
+    printHistory(): void;
+    clear(): void;
+}
+declare abstract class AbstractVisualizationStrategy<T extends IVisualizable> implements IVisualizationStrategy<T> {
+    abstract visualize(array: T[], context: VisualizationContext<T>): void;
+    abstract getName(): string;
+    abstract getDescription(): string;
+    protected getConfig(): Readonly<VisualizationConfig>;
+}
+declare class TimeoutForEachStrategy<T extends IVisualizable> extends AbstractVisualizationStrategy<T> {
+    visualize(array: T[], context: VisualizationContext<T>): void;
+    getName(): string;
+    getDescription(): string;
+}
+declare class ConcreteVisualizationStrategyFactory<T extends IVisualizable> implements IVisualizationStrategyFactory<T> {
+    private strategies;
+    constructor();
+    createStrategy(type: StrategyType): IVisualizationStrategy<T>;
+    registerStrategy(type: StrategyType, strategy: IVisualizationStrategy<T>): void;
+    listAvailableStrategies(): string[];
+    hasStrategy(type: StrategyType): boolean;
+}
+declare class VisualizerBuilder<T extends IVisualizable> {
+    private array?;
+    private strategy?;
+    private observers;
+    private config?;
+    private enableDefaultObservers;
+    setArray(array: T[]): this;
+    setStrategy(strategy: IVisualizationStrategy<T>): this;
+    addObserver(observer: IObserver<T>): this;
+    setConfig(config: Partial<VisualizationConfig>): this;
+    disableDefaultObservers(): this;
+    build(): ArrayVisualizer<T>;
+    reset(): this;
+}
+declare class ArrayVisualizer<T extends IVisualizable> {
+    private array;
+    private strategy;
+    private context;
+    constructor(array: T[], strategy: IVisualizationStrategy<T>);
+    addObserver(observer: IObserver<T>): void;
+    removeObserver(observer: IObserver<T>): void;
+    execute(): void;
+    getContext(): VisualizationContext<T>;
+    getEventHistory(): VisualizationEvent<T>[];
+}
+interface ICommand {
+    execute(): void;
+    getDescription(): string;
+}
+declare class ExecuteVisualizationCommand<T extends IVisualizable> implements ICommand {
+    private visualizer;
+    constructor(visualizer: ArrayVisualizer<T>);
+    execute(): void;
+    getDescription(): string;
+}
+declare class UpdateConfigCommand implements ICommand {
+    private config;
+    constructor(config: Partial<VisualizationConfig>);
+    execute(): void;
+    getDescription(): string;
+}
+declare class CommandInvoker {
+    private commandQueue;
+    private executedCommands;
+    enqueueCommand(command: ICommand): void;
+    executeNext(): void;
+    executeAll(): void;
+    getQueueSize(): number;
+    clearQueue(): void;
+    getExecutedCommands(): ICommand[];
+}
+declare abstract class AbstractVisualizationRunner<T extends IVisualizable> {
+    run(array: T[], strategyType: StrategyType): void;
+    protected abstract beforeRun(): void;
+    protected abstract afterRun(): void;
+    protected buildVisualizer(builder: VisualizerBuilder<T>, array: T[], strategy: IVisualizationStrategy<T>): ArrayVisualizer<T>;
+    protected executeVisualization(visualizer: ArrayVisualizer<T>): void;
+}
+declare class LoggingVisualizationRunner<T extends IVisualizable> extends AbstractVisualizationRunner<T> {
+    protected beforeRun(): void;
+    protected afterRun(): void;
+}
+declare function demonstrateVisualization(): void;
+declare function demonstrateWithTemplateMethod(): void;
+declare function demonstrateWithCustomConfig(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,577 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var EventType;
+(function (EventType) {
+    EventType["STARTED"] = "STARTED";
+    EventType["ELEMENT_DISPLAYED"] = "ELEMENT_DISPLAYED";
+    EventType["COMPLETED"] = "COMPLETED";
+    EventType["ERROR"] = "ERROR";
+})(EventType || (EventType = {}));
+var StrategyType;
+(function (StrategyType) {
+    StrategyType["TIMEOUT_FOREACH"] = "TIMEOUT_FOREACH";
+})(StrategyType || (StrategyType = {}));
+class VisualizableNumber {
+    constructor(value) {
+        this.value = value;
+    }
+    getValue() {
+        return this.value;
+    }
+    toString() {
+        return `${this.value}`;
+    }
+    toDetailedString() {
+        return `VisualizableNumber(${this.value})`;
+    }
+}
+class ConfigurationManager {
+    constructor() {
+        this.config = {
+            baseDelayMs: 1000,
+            enableLogging: true,
+            logPrefix: '',
+            showTimestamps: false,
+            colorize: true
+        };
+    }
+    static getInstance() {
+        if (!ConfigurationManager.instance) {
+            ConfigurationManager.instance = new ConfigurationManager();
+        }
+        return ConfigurationManager.instance;
+    }
+    getConfig() {
+        return Object.freeze({ ...this.config });
+    }
+    updateConfig(partial) {
+        this.config = { ...this.config, ...partial };
+    }
+    resetToDefaults() {
+        this.config = {
+            baseDelayMs: 1000,
+            enableLogging: true,
+            logPrefix: '🎯',
+            showTimestamps: false,
+            colorize: true
+        };
+    }
+}
+function Measure(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        const start = performance.now();
+        const result = originalMethod.apply(this, args);
+        if (result && typeof result.then === 'function') {
+            return result.then((res) => {
+                const end = performance.now();
+                console.log(`${propertyKey} completed in ${(end - start).toFixed(2)}ms`);
+                return res;
+            });
+        }
+        const end = performance.now();
+        console.log(`${propertyKey} executed in ${(end - start).toFixed(2)}ms`);
+        return result;
+    };
+    return descriptor;
+}
+function Log(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        const config = ConfigurationManager.getInstance().getConfig();
+        if (config.enableLogging) {
+            console.log(`Calling ${propertyKey} with ${args.length} argument(s)`);
+        }
+        return originalMethod.apply(this, args);
+    };
+    return descriptor;
+}
+function ValidateArray(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        const array = args[0];
+        if (!Array.isArray(array)) {
+            throw new TypeError(`${propertyKey} expects an array as first argument`);
+        }
+        if (array.length === 0) {
+            throw new Error(`${propertyKey} cannot work with empty array`);
+        }
+        return originalMethod.apply(this, args);
+    };
+    return descriptor;
+}
+class VisualizationContext {
+    constructor(strategyName) {
+        this.strategyName = strategyName;
+        this.observers = new Set();
+        this.eventHistory = [];
+        this.elementCount = 0;
+    }
+    attach(observer) {
+        this.observers.add(observer);
+    }
+    detach(observer) {
+        this.observers.delete(observer);
+    }
+    notify(event) {
+        this.eventHistory.push(event);
+        this.observers.forEach(observer => observer.update(event));
+    }
+    emitStarted() {
+        const event = {
+            type: EventType.STARTED,
+            timestamp: Date.now(),
+            metadata: { strategy: this.strategyName }
+        };
+        this.notify(event);
+    }
+    emitElementDisplayed(element, index, delay) {
+        this.elementCount++;
+        const event = {
+            type: EventType.ELEMENT_DISPLAYED,
+            element,
+            index,
+            timestamp: Date.now(),
+            delay,
+            metadata: { totalDisplayed: this.elementCount }
+        };
+        this.notify(event);
+    }
+    emitCompleted() {
+        const event = {
+            type: EventType.COMPLETED,
+            timestamp: Date.now(),
+            metadata: {
+                strategy: this.strategyName,
+                totalElements: this.elementCount
+            }
+        };
+        this.notify(event);
+    }
+    emitError(error) {
+        const event = {
+            type: EventType.ERROR,
+            timestamp: Date.now(),
+            metadata: { error: error.message }
+        };
+        this.notify(event);
+    }
+    getEventHistory() {
+        return [...this.eventHistory];
+    }
+    getElementCount() {
+        return this.elementCount;
+    }
+    getStrategyName() {
+        return this.strategyName;
+    }
+}
+class ConsoleLoggingObserver {
+    constructor() {
+        this.config = ConfigurationManager.getInstance().getConfig();
+    }
+    update(event) {
+        if (!this.config.enableLogging)
+            return;
+        const timestamp = this.config.showTimestamps
+            ? `[${new Date(event.timestamp).toISOString()}] `
+            : '';
+        switch (event.type) {
+            case EventType.STARTED:
+                console.log(`\n${this.config.logPrefix} ${timestamp}Visualization started: ${event.metadata?.strategy}`);
+                break;
+            case EventType.ELEMENT_DISPLAYED:
+                const delayInfo = event.delay ? ` (delay: ${event.delay}ms)` : '';
+                console.log(`${this.config.logPrefix} ${timestamp}Element ${event.element?.getValue()} displayed${delayInfo}`);
+                break;
+            case EventType.COMPLETED:
+                console.log(`${this.config.logPrefix} ${timestamp}Visualization completed: ${event.metadata?.totalElements} elements\n`);
+                break;
+            case EventType.ERROR:
+                console.error(`${this.config.logPrefix} ${timestamp}Error: ${event.metadata?.error}`);
+                break;
+        }
+    }
+}
+class StatisticsObserver {
+    constructor() {
+        this.startTime = 0;
+        this.endTime = 0;
+        this.displayedElements = 0;
+        this.totalDelay = 0;
+        this.events = new Map();
+    }
+    update(event) {
+        const currentCount = this.events.get(event.type) || 0;
+        this.events.set(event.type, currentCount + 1);
+        switch (event.type) {
+            case EventType.STARTED:
+                this.startTime = event.timestamp;
+                break;
+            case EventType.ELEMENT_DISPLAYED:
+                this.displayedElements++;
+                if (event.delay) {
+                    this.totalDelay += event.delay;
+                }
+                break;
+            case EventType.COMPLETED:
+                this.endTime = event.timestamp;
+                break;
+        }
+    }
+    getStatistics() {
+        return {
+            duration: this.endTime - this.startTime,
+            displayedElements: this.displayedElements,
+            totalDelay: this.totalDelay,
+            averageDelay: this.displayedElements > 0 ? this.totalDelay / this.displayedElements : 0,
+            eventCounts: new Map(this.events)
+        };
+    }
+    printStatistics() {
+        const stats = this.getStatistics();
+        console.log('\n Visualization Statistics:');
+        console.log(`   Duration: ${stats.duration.toFixed(2)}ms`);
+        console.log(`   Elements Displayed: ${stats.displayedElements}`);
+        console.log(`   Total Delay: ${stats.totalDelay}ms`);
+        console.log(`   Average Delay: ${stats.averageDelay.toFixed(2)}ms`);
+        console.log('   Event Counts:');
+        stats.eventCounts.forEach((count, type) => {
+            console.log(`      ${type}: ${count}`);
+        });
+    }
+    reset() {
+        this.startTime = 0;
+        this.endTime = 0;
+        this.displayedElements = 0;
+        this.totalDelay = 0;
+        this.events.clear();
+    }
+}
+class HistoryObserver {
+    constructor() {
+        this.history = [];
+    }
+    update(event) {
+        this.history.push({
+            event,
+            formattedTime: new Date(event.timestamp).toLocaleTimeString()
+        });
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    printHistory() {
+        console.log('\n Visualization History:');
+        this.history.forEach(({ event, formattedTime }, index) => {
+            console.log(`   ${index + 1}. [${formattedTime}] ${event.type}${event.element ? ` - ${event.element.getValue()}` : ''}`);
+        });
+    }
+    clear() {
+        this.history = [];
+    }
+}
+class AbstractVisualizationStrategy {
+    getConfig() {
+        return ConfigurationManager.getInstance().getConfig();
+    }
+}
+class TimeoutForEachStrategy extends AbstractVisualizationStrategy {
+    visualize(array, context) {
+        context.emitStarted();
+        try {
+            array.forEach((element, index) => {
+                const delayMs = element.getValue();
+                setTimeout(() => {
+                    console.log(element.getValue());
+                    context.emitElementDisplayed(element, index, delayMs);
+                    if (index === array.length - 1) {
+                        setTimeout(() => {
+                            context.emitCompleted();
+                        }, 10);
+                    }
+                }, delayMs);
+            });
+        }
+        catch (error) {
+            context.emitError(error);
+            throw error;
+        }
+    }
+    getName() {
+        return 'setTimeout + forEach Strategy';
+    }
+    getDescription() {
+        return 'Visualizes array elements using setTimeout with delay equal to element value: arr.forEach((t) => setTimeout(() => console.log(t), t))';
+    }
+}
+__decorate([
+    Log,
+    ValidateArray,
+    Measure,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, VisualizationContext]),
+    __metadata("design:returntype", void 0)
+], TimeoutForEachStrategy.prototype, "visualize", null);
+class ConcreteVisualizationStrategyFactory {
+    constructor() {
+        this.strategies = new Map();
+        this.registerStrategy(StrategyType.TIMEOUT_FOREACH, new TimeoutForEachStrategy());
+    }
+    createStrategy(type) {
+        const strategy = this.strategies.get(type);
+        if (!strategy) {
+            throw new Error(`Strategy type '${type}' not found. Available: ${this.listAvailableStrategies().join(', ')}`);
+        }
+        return strategy;
+    }
+    registerStrategy(type, strategy) {
+        this.strategies.set(type, strategy);
+    }
+    listAvailableStrategies() {
+        return Array.from(this.strategies.keys());
+    }
+    hasStrategy(type) {
+        return this.strategies.has(type);
+    }
+}
+class VisualizerBuilder {
+    constructor() {
+        this.observers = [];
+        this.enableDefaultObservers = true;
+    }
+    setArray(array) {
+        this.array = array;
+        return this;
+    }
+    setStrategy(strategy) {
+        this.strategy = strategy;
+        return this;
+    }
+    addObserver(observer) {
+        this.observers.push(observer);
+        return this;
+    }
+    setConfig(config) {
+        this.config = config;
+        return this;
+    }
+    disableDefaultObservers() {
+        this.enableDefaultObservers = false;
+        return this;
+    }
+    build() {
+        if (!this.array) {
+            throw new Error('Array is required to build visualizer');
+        }
+        if (!this.strategy) {
+            throw new Error('Strategy is required to build visualizer');
+        }
+        if (this.config) {
+            ConfigurationManager.getInstance().updateConfig(this.config);
+        }
+        const visualizer = new ArrayVisualizer(this.array, this.strategy);
+        if (this.enableDefaultObservers) {
+            visualizer.addObserver(new ConsoleLoggingObserver());
+        }
+        this.observers.forEach(observer => visualizer.addObserver(observer));
+        return visualizer;
+    }
+    reset() {
+        this.array = undefined;
+        this.strategy = undefined;
+        this.observers = [];
+        this.config = undefined;
+        this.enableDefaultObservers = true;
+        return this;
+    }
+}
+class ArrayVisualizer {
+    constructor(array, strategy) {
+        this.array = array;
+        this.strategy = strategy;
+        this.context = new VisualizationContext(strategy.getName());
+    }
+    addObserver(observer) {
+        this.context.attach(observer);
+    }
+    removeObserver(observer) {
+        this.context.detach(observer);
+    }
+    execute() {
+        console.log('\n' + '='.repeat(70));
+        console.log(` ${this.strategy.getName()}`);
+        console.log('='.repeat(70));
+        console.log(` ${this.strategy.getDescription()}`);
+        console.log(` Array: [${this.array.map(x => x.getValue()).join(', ')}]`);
+        console.log('='.repeat(70));
+        this.strategy.visualize([...this.array], this.context);
+    }
+    getContext() {
+        return this.context;
+    }
+    getEventHistory() {
+        return this.context.getEventHistory();
+    }
+}
+__decorate([
+    Measure,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ArrayVisualizer.prototype, "execute", null);
+class ExecuteVisualizationCommand {
+    constructor(visualizer) {
+        this.visualizer = visualizer;
+    }
+    execute() {
+        this.visualizer.execute();
+    }
+    getDescription() {
+        return 'Execute array visualization';
+    }
+}
+class UpdateConfigCommand {
+    constructor(config) {
+        this.config = config;
+    }
+    execute() {
+        ConfigurationManager.getInstance().updateConfig(this.config);
+        console.log('Configuration updated');
+    }
+    getDescription() {
+        return 'Update visualization configuration';
+    }
+}
+class CommandInvoker {
+    constructor() {
+        this.commandQueue = [];
+        this.executedCommands = [];
+    }
+    enqueueCommand(command) {
+        this.commandQueue.push(command);
+    }
+    executeNext() {
+        const command = this.commandQueue.shift();
+        if (command) {
+            console.log(`\n🔧 Executing: ${command.getDescription()}`);
+            command.execute();
+            this.executedCommands.push(command);
+        }
+    }
+    executeAll() {
+        while (this.commandQueue.length > 0) {
+            this.executeNext();
+        }
+    }
+    getQueueSize() {
+        return this.commandQueue.length;
+    }
+    clearQueue() {
+        this.commandQueue = [];
+    }
+    getExecutedCommands() {
+        return [...this.executedCommands];
+    }
+}
+class AbstractVisualizationRunner {
+    run(array, strategyType) {
+        this.beforeRun();
+        const factory = new ConcreteVisualizationStrategyFactory();
+        const strategy = factory.createStrategy(strategyType);
+        const builder = new VisualizerBuilder();
+        const visualizer = this.buildVisualizer(builder, array, strategy);
+        this.executeVisualization(visualizer);
+        this.afterRun();
+    }
+    buildVisualizer(builder, array, strategy) {
+        return builder
+            .setArray(array)
+            .setStrategy(strategy)
+            .build();
+    }
+    executeVisualization(visualizer) {
+        visualizer.execute();
+    }
+}
+class LoggingVisualizationRunner extends AbstractVisualizationRunner {
+    beforeRun() {
+        console.log('\n Starting visualization process...');
+    }
+    afterRun() {
+        console.log('\n Visualization process completed.');
+    }
+}
+function demonstrateVisualization() {
+    ConfigurationManager.getInstance().updateConfig({
+        enableLogging: true,
+        logPrefix: '>',
+        showTimestamps: false
+    });
+    console.log('\n' + '='.repeat(70));
+    console.log('ARRAY VISUALIZATION FRAMEWORK');
+    console.log('  Using setTimeout + forEach Strategy');
+    console.log('='.repeat(70));
+    const numbers = [1, 2, 3];
+    const visualizableArray = numbers.map(n => new VisualizableNumber(n));
+    console.log(`\n Input array: [${numbers.join(', ')}]`);
+    console.log(' Each element will be displayed after a delay equal to its value (in milliseconds)\n');
+    const factory = new ConcreteVisualizationStrategyFactory();
+    const strategy = factory.createStrategy(StrategyType.TIMEOUT_FOREACH);
+    const statisticsObserver = new StatisticsObserver();
+    const historyObserver = new HistoryObserver();
+    const builder = new VisualizerBuilder();
+    const visualizer = builder
+        .setArray(visualizableArray)
+        .setStrategy(strategy)
+        .addObserver(statisticsObserver)
+        .addObserver(historyObserver)
+        .build();
+    const invoker = new CommandInvoker();
+    const visualizationCommand = new ExecuteVisualizationCommand(visualizer);
+    invoker.enqueueCommand(visualizationCommand);
+    invoker.executeAll();
+    setTimeout(() => {
+        console.log('\n' + '─'.repeat(70));
+        statisticsObserver.printStatistics();
+        historyObserver.printHistory();
+        console.log('\n' + '='.repeat(70));
+        console.log('DEMONSTRATION COMPLETED');
+        console.log('='.repeat(70) + '\n');
+    }, 5000);
+}
+function demonstrateWithTemplateMethod() {
+    const numbers = [1, 2, 3];
+    const visualizableArray = numbers.map(n => new VisualizableNumber(n));
+    const runner = new LoggingVisualizationRunner();
+    runner.run(visualizableArray, StrategyType.TIMEOUT_FOREACH);
+}
+function demonstrateWithCustomConfig() {
+    const numbers = [100, 200, 300];
+    const visualizableArray = numbers.map(n => new VisualizableNumber(n));
+    const invoker = new CommandInvoker();
+    const configCommand = new UpdateConfigCommand({
+        logPrefix: '[TIMEOUT_FOREACH FRAMEWORK] ',
+        showTimestamps: true
+    });
+    invoker.enqueueCommand(configCommand);
+    const factory = new ConcreteVisualizationStrategyFactory();
+    const strategy = factory.createStrategy(StrategyType.TIMEOUT_FOREACH);
+    const visualizer = new VisualizerBuilder()
+        .setArray(visualizableArray)
+        .setStrategy(strategy)
+        .build();
+    const visualizationCommand = new ExecuteVisualizationCommand(visualizer);
+    invoker.enqueueCommand(visualizationCommand);
+    invoker.executeAll();
+}
+console.log('\n Starting demonstration...\n');
+demonstrateVisualization();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "the-best-sort",
+  "version": "1.0.0",
+  "description": "Sorting framework basid on best design patterns with the most powerful sort strategies in TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "typescript",
+    "sort",
+    "design-patterns",
+    "visualization",
+    "observer-pattern",
+    "strategy-pattern",
+    "factory-pattern",
+    "builder-pattern",
+    "async",
+    "async-visualization"
+  ],
+  "author": "Danila Grigoriev <danila.sar@yandex.ru> (http://danilasar.ru)",
+  "license": "GLWT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danilasar/the-best-sort.git"
+  },
+  "bugs": {
+    "url": "https://github.com/danilasar/the-best-sort/issues"
+  },
+  "homepage": "https://github.com/danilasar/the-best-sort#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0",
+    "tsx": "^4.20.6"
+  }
+}