the-best-sort 1.0.3 → 1.2.0

package/README.md

@@ -1,10 +1,12 @@
 # The Best Sort
 
-A comprehensive AI-friendly TypeScript library for array sorting and asynchronous processing using powerful strategy  with advanced object-oriented programming patterns and design principles.
+A comprehensive AI-friendly TypeScript library for array sorting 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.
+The Best Sort is a production-ready TypeScript framework designed to handle efficient sorting operations at scale. At its core, it implements a powerful asynchronous sleep sort strategy, enabling you to sort large datasets with concurrent processing capabilities. The framework leverages event-driven architecture to provide real-time observability into sorting progress, making it practical for production environments where monitoring and performance insights matter.
+
+Whether you're sorting massive collections, processing data streams, or integrating sorting into AI agent workflows, The Best Sort delivers type-safe, extensible sorting solutions. Built with modern software engineering practices, it provides both a reliable tool for practical sorting tasks and a learning resource for developers seeking to understand how sophisticated sorting systems are implemented in contemporary applications.
 
 ## Installation
 
@@ -35,40 +37,51 @@ npx tsc src/index.ts --experimentalDecorators --emitDecoratorMetadata
 node the-best-sort.js
 ```
 
-## Design Patterns
+## Advanced Sorting Strategies
 
-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.
+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 so you can implement flexible, adaptive sorting solutions for any dataset.
 
 
 ## Core Components
 
-### VisualizableNumber
+### SortableNumber
 
-A comparable number wrapper implementing the `IVisualizable` interface:
+A comparable number wrapper implementing the `SortableNumber` interface:
 
 ```typescript
-const nums =.map(n => new VisualizableNumber(n));
+const nums = [1, 2, 3].map(n => new SortableNumber(n));
 ```
 
 
-### VisualizationContext
+### SortingContext
 
 Manages state and event notifications during visualization:
 
 ```typescript
-const context = new VisualizationContext<VisualizableNumber>("Strategy Name");
+const context = new SortingContext<SortableNumber>("Strategy Name");
 context.attach(observer);
 context.emitElementDisplayed(element, index, delay);
 ```
 
+## StrategyFactory
+
+Create sorting strategies through the factory:
+
+```typescript
+const factory = new ConcreteSortingStrategyFactory<SortableNumber>();
+const strategy = factory.createStrategy(StrategyType.DEFAULT);
+```
+
 
 ### Observers
 
 Track visualization events and collect metrics:
 
 ```typescript
-const statsObserver = new StatisticsObserver<VisualizableNumber>();
-visualizer.addObserver(statsObserver);
+const statsObserver = new StatisticsObserver<SortableNumber>();
+const historyObserver = new HistoryObserver<SortableNumber>();
+sorter.addObserver(statsObserver);
+sorter.addObserver(historyObserver);
 ```
 
 
@@ -88,21 +101,21 @@ ConfigurationManager.getInstance().updateConfig({
 
 ## Event Types
 
-The library emits the following event types during visualization:
+The library emits the following event types during sorting:
 
-- `STARTED` - Visualization has started
-- `ELEMENT_DISPLAYED` - An array element was displayed
-- `COMPLETED` - Visualization has completed
-- `ERROR` - An error occurred during visualization
+- `STARTED` - Sorting has started
+- `ELEMENT_SORTED` - An array element was processed and added to result
+- `COMPLETED` - Sorting has completed
+- `ERROR` - An error occurred during sorting
 
 ## Performance Metrics
 
 `StatisticsObserver` collects the following metrics:
 
 ```typescript
-interface VisualizationStatistics {
+interface SortingStatistics {
   duration: number; // Total duration in milliseconds
-  displayedElements: number; // Number of elements displayed
+  sortedElements: number; // Number of elements sorted
   totalDelay: number; // Sum of all delays
   averageDelay: number; // Average delay per element
   eventCounts: Map<EventType, number>; // Event counts by type
@@ -114,11 +127,11 @@ interface VisualizationStatistics {
 
 The library follows a layered architecture:
 
-1. **Core Domain** - `VisualizableNumber`, event types, configuration
+1. **Core Domain** - `SortableNumber`, 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
+3. **Context Layer** - `SortingContext` managing state and notifications
+4. **Observer Layer** - Multiple observer implementations (Console, Statistics, History)
+5. **Application Layer** - `ArraySorter`, `CommandInvoker`, runners
 6. **Factory Layer** - Strategy and builder creation
 
 ## TypeScript Features Used
@@ -131,55 +144,138 @@ The library follows a layered architecture:
 - Readonly types for immutability
 - Object destructuring and spreading
 
+## Usage
+
+Basic usage:
+
+```typescript
+const numbers = [1, 100, 10];​
+const sortableArray = numbers.map(n => new SortableNumber(n));
+
+const factory = new ConcreteSortingStrategyFactory<SortableNumber>();
+const strategy = factory.createStrategy(StrategyType.DEFAULT);
+
+const sorter = new SorterBuilder<SortableNumber>()
+  .setArray(sortableArray)
+  .setStrategy(strategy)
+  .build();
+
+const sortedArray = await sorter.execute();
+console.log(sortedArray)
+```
+
+### With custom observers
+
+```typescript
+const statisticsObserver = new StatisticsObserver<SortableNumber>();
+const historyObserver = new HistoryObserver<SortableNumber>();
+
+const sorter = new SorterBuilder<SortableNumber>()
+.setArray(sortableArray)
+.setStrategy(strategy)
+.addObserver(statisticsObserver)
+.addObserver(historyObserver)
+.build();
+
+await sorter.execute();
+statisticsObserver.printStatistics();
+historyObserver.printHistory();
+```
+
+### Using command pattern
+
+```typescript
+const invoker = new CommandInvoker();
+const sortingCommand = new ExecuteSortingCommand(sorter);
+
+invoker.enqueueCommand(sortingCommand);
+const results = await invoker.executeAll();
+```
+
+### Using template method pattern
+
+```typescript
+const runner = new LoggingSortingRunner<SortableNumber>();
+const sortedArray = await runner.run(sortableArray, StrategyType.DEFAULT);
+```
+
 ## Extending the Library
 
 ### Creating Custom Observers
 
 ```typescript
-class CustomObserver<T extends IVisualizable> implements IObserver<T> {
-  update(event: VisualizationEvent<T>): void {
-    // Custom logic here
+class MetricsObserver<T extends ISortable> implements IObserver<T> {
+  update(event: SortingEvent<T>): void {
+    if (event.type === EventType.ELEMENT_SORTED) {
+      // Custom logic here
+    }
+  }
+}
+
+sorter.addObserver(new MetricsObserver());
+```
+
+### Creating custom strategies
+
+```typescript
+class BubbleSortStrategy<T extends ISortable>
+extends AbstractSortingStrategy<T> {
+
+  sort(array: T[], context: SortingContext<T>): Promise<T[]> {
+    context.emitStarted();
+    // Implementation
+    context.emitCompleted();
+    return Promise.resolve(result);
+  }
+
+  getName(): string {
+    return 'Bubble Sort Strategy';
+  }
+
+  getDescription(): string {
+    return 'Classic bubble sort implementation';
   }
 }
 
-visualizer.addObserver(new CustomObserver());
+// Register strategy
+factory.registerStrategy(StrategyType.BUBBLE, new BubbleSortStrategy());
 ```
 
 
 ### Creating Custom Commands
 
 ```typescript
-class CustomCommand implements ICommand {
-  execute(): void {
-    // Custom command logic
+class ResetCommand implements ICommand {
+  async execute(): Promise<void> {
+    ConfigurationManager.getInstance().resetToDefaults();
   }
 
   getDescription(): string {
-    return "Custom command description";
+    return 'Reset configuration to defaults';
   }
 }
 
-invoker.enqueueCommand(new CustomCommand());
+invoker.enqueueCommand(new ResetCommand());
 ```
 
 
 ### Creating Custom Runners
 
 ```typescript
-class CustomRunner<T extends IVisualizable>
-extends AbstractVisualizationRunner<T> {
-  
+class MetricsSortingRunner<T extends ISortable>
+extends AbstractSortingRunner<T> {
+
   protected beforeRun(): void {
-    console.log("Before run");
+    console.log('Initializing sorting with metrics...');
   }
-  
+
   protected afterRun(): void {
-    console.log("After run");
+    console.log('Sorting completed with full metrics');
   }
 }
 
-const runner = new CustomRunner<VisualizableNumber>();
-runner.run(array, StrategyType.TIMEOUT_FOREACH);
+const runner = new MetricsSortingRunner<SortableNumber>();
+const result = await runner.run(sortableArray, StrategyType.DEFAULT);
 ```
 
 ## Requirements
@@ -190,9 +286,7 @@ runner.run(array, StrategyType.TIMEOUT_FOREACH);
 
 ## 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
 

package/dist/index.d.ts

@@ -1,22 +1,22 @@
-interface IVisualizable {
+export interface ISortable {
     getValue(): number;
     toString(): string;
 }
-interface IObserver<T> {
-    update(event: VisualizationEvent<T>): void;
+export interface IObserver<T> {
+    update(event: SortingEvent<T>): void;
 }
-interface ISubject<T> {
+export interface ISubject<T> {
     attach(observer: IObserver<T>): void;
     detach(observer: IObserver<T>): void;
-    notify(event: VisualizationEvent<T>): void;
+    notify(event: SortingEvent<T>): void;
 }
-declare enum EventType {
+export declare enum EventType {
     STARTED = "STARTED",
-    ELEMENT_DISPLAYED = "ELEMENT_DISPLAYED",
+    ELEMENT_SORTED = "ELEMENT_SORTED",
     COMPLETED = "COMPLETED",
     ERROR = "ERROR"
 }
-interface VisualizationEvent<T> {
+export interface SortingEvent<T> {
     type: EventType;
     element?: T;
     index?: number;
@@ -24,46 +24,43 @@ interface VisualizationEvent<T> {
     delay?: number;
     metadata?: Record<string, any>;
 }
-interface IVisualizationStrategy<T extends IVisualizable> {
-    visualize(array: T[], context: VisualizationContext<T>): void;
+export interface ISortingStrategy<T extends ISortable> {
+    sort(array: T[], context: SortingContext<T>): Promise<T[]>;
     getName(): string;
     getDescription(): string;
 }
-interface IVisualizationStrategyFactory<T extends IVisualizable> {
-    createStrategy(type: StrategyType): IVisualizationStrategy<T>;
-    registerStrategy(type: StrategyType, strategy: IVisualizationStrategy<T>): void;
+export interface ISortingStrategyFactory<T extends ISortable> {
+    createStrategy(type: StrategyType): ISortingStrategy<T>;
+    registerStrategy(type: StrategyType, strategy: ISortingStrategy<T>): void;
     listAvailableStrategies(): string[];
 }
-declare enum StrategyType {
-    TIMEOUT_FOREACH = "TIMEOUT_FOREACH"
+export declare enum StrategyType {
+    DEFAULT = "DEFAULT"
 }
-interface VisualizationConfig {
+export interface SortingConfig {
     baseDelayMs: number;
     enableLogging: boolean;
     logPrefix: string;
     showTimestamps: boolean;
     colorize: boolean;
 }
-declare class VisualizableNumber implements IVisualizable {
+export declare class SortableNumber implements ISortable {
     private readonly value;
     constructor(value: number);
     getValue(): number;
     toString(): string;
     toDetailedString(): string;
 }
-declare class ConfigurationManager {
+export declare class ConfigurationManager {
     private static instance;
     private config;
     private constructor();
     static getInstance(): ConfigurationManager;
-    getConfig(): Readonly<VisualizationConfig>;
-    updateConfig(partial: Partial<VisualizationConfig>): void;
+    getConfig(): Readonly<SortingConfig>;
+    updateConfig(partial: Partial<SortingConfig>): 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> {
+export declare class SortingContext<T extends ISortable> implements ISubject<T> {
     private strategyName;
     private observers;
     private eventHistory;
@@ -71,129 +68,129 @@ declare class VisualizationContext<T extends IVisualizable> implements ISubject<
     constructor(strategyName: string);
     attach(observer: IObserver<T>): void;
     detach(observer: IObserver<T>): void;
-    notify(event: VisualizationEvent<T>): void;
+    notify(event: SortingEvent<T>): void;
     emitStarted(): void;
-    emitElementDisplayed(element: T, index: number, delay: number): void;
+    emitElementSorted(element: T, index: number, delay: number): void;
     emitCompleted(): void;
     emitError(error: Error): void;
-    getEventHistory(): VisualizationEvent<T>[];
+    getEventHistory(): SortingEvent<T>[];
     getElementCount(): number;
     getStrategyName(): string;
 }
-declare class ConsoleLoggingObserver<T extends IVisualizable> implements IObserver<T> {
+export declare class ConsoleLoggingObserver<T extends ISortable> implements IObserver<T> {
     private config;
-    update(event: VisualizationEvent<T>): void;
+    update(event: SortingEvent<T>): void;
 }
-declare class StatisticsObserver<T extends IVisualizable> implements IObserver<T> {
+export declare class StatisticsObserver<T extends ISortable> implements IObserver<T> {
     private startTime;
     private endTime;
-    private displayedElements;
+    private sortedElements;
     private totalDelay;
     private events;
-    update(event: VisualizationEvent<T>): void;
-    getStatistics(): VisualizationStatistics;
+    update(event: SortingEvent<T>): void;
+    getStatistics(): SortingStatistics;
     printStatistics(): void;
     reset(): void;
 }
-interface VisualizationStatistics {
+export interface SortingStatistics {
     duration: number;
-    displayedElements: number;
+    sortedElements: number;
     totalDelay: number;
     averageDelay: number;
     eventCounts: Map<EventType, number>;
 }
-declare class HistoryObserver<T extends IVisualizable> implements IObserver<T> {
+export declare class HistoryObserver<T extends ISortable> implements IObserver<T> {
     private history;
-    update(event: VisualizationEvent<T>): void;
+    update(event: SortingEvent<T>): void;
     getHistory(): Array<{
-        event: VisualizationEvent<T>;
+        event: SortingEvent<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;
+export declare abstract class AbstractSortingStrategy<T extends ISortable> implements ISortingStrategy<T> {
+    abstract sort(array: T[], context: SortingContext<T>): Promise<T[]>;
     abstract getName(): string;
     abstract getDescription(): string;
-    protected getConfig(): Readonly<VisualizationConfig>;
+    protected getConfig(): Readonly<SortingConfig>;
 }
-declare class TimeoutForEachStrategy<T extends IVisualizable> extends AbstractVisualizationStrategy<T> {
-    visualize(array: T[], context: VisualizationContext<T>): void;
+export declare class DefaultStrategy<T extends ISortable> extends AbstractSortingStrategy<T> {
+    sort(array: T[], context: SortingContext<T>): Promise<T[]>;
     getName(): string;
     getDescription(): string;
 }
-declare class ConcreteVisualizationStrategyFactory<T extends IVisualizable> implements IVisualizationStrategyFactory<T> {
+export declare class ConcreteSortingStrategyFactory<T extends ISortable> implements ISortingStrategyFactory<T> {
     private strategies;
     constructor();
-    createStrategy(type: StrategyType): IVisualizationStrategy<T>;
-    registerStrategy(type: StrategyType, strategy: IVisualizationStrategy<T>): void;
+    createStrategy(type: StrategyType): ISortingStrategy<T>;
+    registerStrategy(type: StrategyType, strategy: ISortingStrategy<T>): void;
     listAvailableStrategies(): string[];
     hasStrategy(type: StrategyType): boolean;
 }
-declare class VisualizerBuilder<T extends IVisualizable> {
+export declare class SorterBuilder<T extends ISortable> {
     private array?;
     private strategy?;
     private observers;
     private config?;
     private enableDefaultObservers;
     setArray(array: T[]): this;
-    setStrategy(strategy: IVisualizationStrategy<T>): this;
+    setStrategy(strategy: ISortingStrategy<T>): this;
     addObserver(observer: IObserver<T>): this;
-    setConfig(config: Partial<VisualizationConfig>): this;
+    setConfig(config: Partial<SortingConfig>): this;
     disableDefaultObservers(): this;
-    build(): ArrayVisualizer<T>;
+    build(): ArraySorter<T>;
     reset(): this;
 }
-declare class ArrayVisualizer<T extends IVisualizable> {
+export declare class ArraySorter<T extends ISortable> {
     private array;
     private strategy;
     private context;
-    constructor(array: T[], strategy: IVisualizationStrategy<T>);
+    constructor(array: T[], strategy: ISortingStrategy<T>);
     addObserver(observer: IObserver<T>): void;
     removeObserver(observer: IObserver<T>): void;
-    execute(): void;
-    getContext(): VisualizationContext<T>;
-    getEventHistory(): VisualizationEvent<T>[];
+    execute(): Promise<T[]>;
+    getContext(): SortingContext<T>;
+    getEventHistory(): SortingEvent<T>[];
 }
-interface ICommand {
-    execute(): void;
+export interface ICommand {
+    execute(): Promise<any>;
     getDescription(): string;
 }
-declare class ExecuteVisualizationCommand<T extends IVisualizable> implements ICommand {
-    private visualizer;
-    constructor(visualizer: ArrayVisualizer<T>);
-    execute(): void;
+export declare class ExecuteSortingCommand<T extends ISortable> implements ICommand {
+    private sorter;
+    constructor(sorter: ArraySorter<T>);
+    execute(): Promise<T[]>;
     getDescription(): string;
 }
-declare class UpdateConfigCommand implements ICommand {
+export declare class UpdateConfigCommand implements ICommand {
     private config;
-    constructor(config: Partial<VisualizationConfig>);
-    execute(): void;
+    constructor(config: Partial<SortingConfig>);
+    execute(): Promise<void>;
     getDescription(): string;
 }
-declare class CommandInvoker {
+export declare class CommandInvoker {
     private commandQueue;
     private executedCommands;
     enqueueCommand(command: ICommand): void;
-    executeNext(): void;
-    executeAll(): void;
+    executeNext(): Promise<any>;
+    executeAll(): Promise<any[]>;
     getQueueSize(): number;
     clearQueue(): void;
     getExecutedCommands(): ICommand[];
 }
-declare abstract class AbstractVisualizationRunner<T extends IVisualizable> {
-    run(array: T[], strategyType: StrategyType): void;
+export declare abstract class AbstractSortingRunner<T extends ISortable> {
+    run(array: T[], strategyType: StrategyType): Promise<T[]>;
     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;
+    protected buildSorter(builder: SorterBuilder<T>, array: T[], strategy: ISortingStrategy<T>): ArraySorter<T>;
+    protected executeSorting(sorter: ArraySorter<T>): Promise<T[]>;
 }
-declare class LoggingVisualizationRunner<T extends IVisualizable> extends AbstractVisualizationRunner<T> {
+export declare class LoggingSortingRunner<T extends ISortable> extends AbstractSortingRunner<T> {
     protected beforeRun(): void;
     protected afterRun(): void;
 }
-declare function demonstrateVisualization(): void;
-declare function demonstrateWithTemplateMethod(): void;
-declare function demonstrateWithCustomConfig(): void;
+export declare function demonstrateSorting(): Promise<void>;
+export declare function demonstrateWithTemplateMethod(): Promise<void>;
+export declare function demonstrateWithCustomConfig(): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -8,18 +8,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingSortingRunner = exports.AbstractSortingRunner = exports.CommandInvoker = exports.UpdateConfigCommand = exports.ExecuteSortingCommand = exports.ArraySorter = exports.SorterBuilder = exports.ConcreteSortingStrategyFactory = exports.DefaultStrategy = exports.AbstractSortingStrategy = exports.HistoryObserver = exports.StatisticsObserver = exports.ConsoleLoggingObserver = exports.SortingContext = exports.ConfigurationManager = exports.SortableNumber = exports.StrategyType = exports.EventType = void 0;
+exports.demonstrateSorting = demonstrateSorting;
+exports.demonstrateWithTemplateMethod = demonstrateWithTemplateMethod;
+exports.demonstrateWithCustomConfig = demonstrateWithCustomConfig;
 var EventType;
 (function (EventType) {
     EventType["STARTED"] = "STARTED";
-    EventType["ELEMENT_DISPLAYED"] = "ELEMENT_DISPLAYED";
+    EventType["ELEMENT_SORTED"] = "ELEMENT_SORTED";
     EventType["COMPLETED"] = "COMPLETED";
     EventType["ERROR"] = "ERROR";
-})(EventType || (EventType = {}));
+})(EventType || (exports.EventType = EventType = {}));
 var StrategyType;
 (function (StrategyType) {
-    StrategyType["TIMEOUT_FOREACH"] = "TIMEOUT_FOREACH";
-})(StrategyType || (StrategyType = {}));
-class VisualizableNumber {
+    StrategyType["DEFAULT"] = "DEFAULT";
+})(StrategyType || (exports.StrategyType = StrategyType = {}));
+class SortableNumber {
     constructor(value) {
         this.value = value;
     }
@@ -30,15 +35,16 @@ class VisualizableNumber {
         return `${this.value}`;
     }
     toDetailedString() {
-        return `VisualizableNumber(${this.value})`;
+        return `SortableNumber(${this.value})`;
     }
 }
+exports.SortableNumber = SortableNumber;
 class ConfigurationManager {
     constructor() {
         this.config = {
             baseDelayMs: 1000,
             enableLogging: true,
-            logPrefix: '',
+            logPrefix: '🎯',
             showTimestamps: false,
             colorize: true
         };
@@ -65,6 +71,7 @@ class ConfigurationManager {
         };
     }
 }
+exports.ConfigurationManager = ConfigurationManager;
 function Measure(target, propertyKey, descriptor) {
     const originalMethod = descriptor.value;
     descriptor.value = function (...args) {
@@ -108,7 +115,7 @@ function ValidateArray(target, propertyKey, descriptor) {
     };
     return descriptor;
 }
-class VisualizationContext {
+class SortingContext {
     constructor(strategyName) {
         this.strategyName = strategyName;
         this.observers = new Set();
@@ -133,15 +140,15 @@ class VisualizationContext {
         };
         this.notify(event);
     }
-    emitElementDisplayed(element, index, delay) {
+    emitElementSorted(element, index, delay) {
         this.elementCount++;
         const event = {
-            type: EventType.ELEMENT_DISPLAYED,
+            type: EventType.ELEMENT_SORTED,
             element,
             index,
             timestamp: Date.now(),
             delay,
-            metadata: { totalDisplayed: this.elementCount }
+            metadata: { totalSorted: this.elementCount }
         };
         this.notify(event);
     }
@@ -174,6 +181,7 @@ class VisualizationContext {
         return this.strategyName;
     }
 }
+exports.SortingContext = SortingContext;
 class ConsoleLoggingObserver {
     constructor() {
         this.config = ConfigurationManager.getInstance().getConfig();
@@ -186,14 +194,14 @@ class ConsoleLoggingObserver {
             : '';
         switch (event.type) {
             case EventType.STARTED:
-                console.log(`\n${this.config.logPrefix} ${timestamp}Visualization started: ${event.metadata?.strategy}`);
+                console.log(`\n${this.config.logPrefix} ${timestamp}Sorting started: ${event.metadata?.strategy}`);
                 break;
-            case EventType.ELEMENT_DISPLAYED:
+            case EventType.ELEMENT_SORTED:
                 const delayInfo = event.delay ? ` (delay: ${event.delay}ms)` : '';
-                console.log(`${this.config.logPrefix} ${timestamp}Element ${event.element?.getValue()} displayed${delayInfo}`);
+                console.log(`${this.config.logPrefix} ${timestamp}Element ${event.element?.getValue()} added to result${delayInfo}`);
                 break;
             case EventType.COMPLETED:
-                console.log(`${this.config.logPrefix} ${timestamp}Visualization completed: ${event.metadata?.totalElements} elements\n`);
+                console.log(`${this.config.logPrefix} ${timestamp}Sorting completed: ${event.metadata?.totalElements} elements\n`);
                 break;
             case EventType.ERROR:
                 console.error(`${this.config.logPrefix} ${timestamp}Error: ${event.metadata?.error}`);
@@ -201,11 +209,12 @@ class ConsoleLoggingObserver {
         }
     }
 }
+exports.ConsoleLoggingObserver = ConsoleLoggingObserver;
 class StatisticsObserver {
     constructor() {
         this.startTime = 0;
         this.endTime = 0;
-        this.displayedElements = 0;
+        this.sortedElements = 0;
         this.totalDelay = 0;
         this.events = new Map();
     }
@@ -216,8 +225,8 @@ class StatisticsObserver {
             case EventType.STARTED:
                 this.startTime = event.timestamp;
                 break;
-            case EventType.ELEMENT_DISPLAYED:
-                this.displayedElements++;
+            case EventType.ELEMENT_SORTED:
+                this.sortedElements++;
                 if (event.delay) {
                     this.totalDelay += event.delay;
                 }
@@ -230,17 +239,17 @@ class StatisticsObserver {
     getStatistics() {
         return {
             duration: this.endTime - this.startTime,
-            displayedElements: this.displayedElements,
+            sortedElements: this.sortedElements,
             totalDelay: this.totalDelay,
-            averageDelay: this.displayedElements > 0 ? this.totalDelay / this.displayedElements : 0,
+            averageDelay: this.sortedElements > 0 ? this.totalDelay / this.sortedElements : 0,
             eventCounts: new Map(this.events)
         };
     }
     printStatistics() {
         const stats = this.getStatistics();
-        console.log('\n Visualization Statistics:');
+        console.log('\n📊 Sorting Statistics:');
         console.log(`   Duration: ${stats.duration.toFixed(2)}ms`);
-        console.log(`   Elements Displayed: ${stats.displayedElements}`);
+        console.log(`   Elements Sorted: ${stats.sortedElements}`);
         console.log(`   Total Delay: ${stats.totalDelay}ms`);
         console.log(`   Average Delay: ${stats.averageDelay.toFixed(2)}ms`);
         console.log('   Event Counts:');
@@ -251,11 +260,12 @@ class StatisticsObserver {
     reset() {
         this.startTime = 0;
         this.endTime = 0;
-        this.displayedElements = 0;
+        this.sortedElements = 0;
         this.totalDelay = 0;
         this.events.clear();
     }
 }
+exports.StatisticsObserver = StatisticsObserver;
 class HistoryObserver {
     constructor() {
         this.history = [];
@@ -270,7 +280,7 @@ class HistoryObserver {
         return [...this.history];
     }
     printHistory() {
-        console.log('\n Visualization History:');
+        console.log('\n📜 Sorting History:');
         this.history.forEach(({ event, formattedTime }, index) => {
             console.log(`   ${index + 1}. [${formattedTime}] ${event.type}${event.element ? ` - ${event.element.getValue()}` : ''}`);
         });
@@ -279,52 +289,61 @@ class HistoryObserver {
         this.history = [];
     }
 }
-class AbstractVisualizationStrategy {
+exports.HistoryObserver = HistoryObserver;
+class AbstractSortingStrategy {
     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(() => {
+exports.AbstractSortingStrategy = AbstractSortingStrategy;
+class DefaultStrategy extends AbstractSortingStrategy {
+    sort(array, context) {
+        return new Promise((resolve, reject) => {
+            context.emitStarted();
+            const result = [];
+            let completedCount = 0;
+            const totalElements = array.length;
+            try {
+                array.forEach((element, index) => {
+                    const delayMs = element.getValue();
+                    setTimeout(() => {
+                        result.push(element);
+                        console.log(`Added to result array: ${element.getValue()}`);
+                        context.emitElementSorted(element, index, delayMs);
+                        completedCount++;
+                        if (completedCount === totalElements) {
                             context.emitCompleted();
-                        }, 10);
-                    }
-                }, delayMs);
-            });
-        }
-        catch (error) {
-            context.emitError(error);
-            throw error;
-        }
+                            resolve(result);
+                        }
+                    }, delayMs);
+                });
+            }
+            catch (error) {
+                context.emitError(error);
+                reject(error);
+            }
+        });
     }
     getName() {
-        return 'setTimeout + forEach Strategy';
+        return 'Default Fast Strategy (Sleep Sort)';
     }
     getDescription() {
-        return 'Visualizes array elements using setTimeout with delay equal to element value: arr.forEach((t) => setTimeout(() => console.log(t), t))';
+        return 'Sorts array using blazing fast algorithm. Elements are added to result array in order of completion.';
     }
 }
+exports.DefaultStrategy = DefaultStrategy;
 __decorate([
     Log,
     ValidateArray,
     Measure,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, VisualizationContext]),
-    __metadata("design:returntype", void 0)
-], TimeoutForEachStrategy.prototype, "visualize", null);
-class ConcreteVisualizationStrategyFactory {
+    __metadata("design:paramtypes", [Array, SortingContext]),
+    __metadata("design:returntype", Promise)
+], DefaultStrategy.prototype, "sort", null);
+class ConcreteSortingStrategyFactory {
     constructor() {
         this.strategies = new Map();
-        this.registerStrategy(StrategyType.TIMEOUT_FOREACH, new TimeoutForEachStrategy());
+        this.registerStrategy(StrategyType.DEFAULT, new DefaultStrategy());
     }
     createStrategy(type) {
         const strategy = this.strategies.get(type);
@@ -343,7 +362,8 @@ class ConcreteVisualizationStrategyFactory {
         return this.strategies.has(type);
     }
 }
-class VisualizerBuilder {
+exports.ConcreteSortingStrategyFactory = ConcreteSortingStrategyFactory;
+class SorterBuilder {
     constructor() {
         this.observers = [];
         this.enableDefaultObservers = true;
@@ -370,20 +390,20 @@ class VisualizerBuilder {
     }
     build() {
         if (!this.array) {
-            throw new Error('Array is required to build visualizer');
+            throw new Error('Array is required to build sorter');
         }
         if (!this.strategy) {
-            throw new Error('Strategy is required to build visualizer');
+            throw new Error('Strategy is required to build sorter');
         }
         if (this.config) {
             ConfigurationManager.getInstance().updateConfig(this.config);
         }
-        const visualizer = new ArrayVisualizer(this.array, this.strategy);
+        const sorter = new ArraySorter(this.array, this.strategy);
         if (this.enableDefaultObservers) {
-            visualizer.addObserver(new ConsoleLoggingObserver());
+            sorter.addObserver(new ConsoleLoggingObserver());
         }
-        this.observers.forEach(observer => visualizer.addObserver(observer));
-        return visualizer;
+        this.observers.forEach(observer => sorter.addObserver(observer));
+        return sorter;
     }
     reset() {
         this.array = undefined;
@@ -394,11 +414,12 @@ class VisualizerBuilder {
         return this;
     }
 }
-class ArrayVisualizer {
+exports.SorterBuilder = SorterBuilder;
+class ArraySorter {
     constructor(array, strategy) {
         this.array = array;
         this.strategy = strategy;
-        this.context = new VisualizationContext(strategy.getName());
+        this.context = new SortingContext(strategy.getName());
     }
     addObserver(observer) {
         this.context.attach(observer);
@@ -406,14 +427,18 @@ class ArrayVisualizer {
     removeObserver(observer) {
         this.context.detach(observer);
     }
-    execute() {
+    async execute() {
         console.log('\n' + '='.repeat(70));
-        console.log(` ${this.strategy.getName()}`);
+        console.log(`🔄 ${this.strategy.getName()}`);
+        console.log('='.repeat(70));
+        console.log(`📝 ${this.strategy.getDescription()}`);
+        console.log(`📥 Input array: [${this.array.map(x => x.getValue()).join(', ')}]`);
         console.log('='.repeat(70));
-        console.log(` ${this.strategy.getDescription()}`);
-        console.log(` Array: [${this.array.map(x => x.getValue()).join(', ')}]`);
+        const result = await this.strategy.sort([...this.array], this.context);
+        console.log('\n' + '='.repeat(70));
+        console.log(`✅ Sorted result: [${result.map(x => x.getValue()).join(', ')}]`);
         console.log('='.repeat(70));
-        this.strategy.visualize([...this.array], this.context);
+        return result;
     }
     getContext() {
         return this.context;
@@ -422,35 +447,38 @@ class ArrayVisualizer {
         return this.context.getEventHistory();
     }
 }
+exports.ArraySorter = ArraySorter;
 __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;
+    __metadata("design:returntype", Promise)
+], ArraySorter.prototype, "execute", null);
+class ExecuteSortingCommand {
+    constructor(sorter) {
+        this.sorter = sorter;
     }
-    execute() {
-        this.visualizer.execute();
+    async execute() {
+        return await this.sorter.execute();
     }
     getDescription() {
-        return 'Execute array visualization';
+        return 'Execute array sorting';
     }
 }
+exports.ExecuteSortingCommand = ExecuteSortingCommand;
 class UpdateConfigCommand {
     constructor(config) {
         this.config = config;
     }
-    execute() {
+    async execute() {
         ConfigurationManager.getInstance().updateConfig(this.config);
-        console.log('Configuration updated');
+        console.log('✅ Configuration updated');
     }
     getDescription() {
-        return 'Update visualization configuration';
+        return 'Update sorting configuration';
     }
 }
+exports.UpdateConfigCommand = UpdateConfigCommand;
 class CommandInvoker {
     constructor() {
         this.commandQueue = [];
@@ -459,18 +487,22 @@ class CommandInvoker {
     enqueueCommand(command) {
         this.commandQueue.push(command);
     }
-    executeNext() {
+    async executeNext() {
         const command = this.commandQueue.shift();
         if (command) {
             console.log(`\n🔧 Executing: ${command.getDescription()}`);
-            command.execute();
+            const result = await command.execute();
             this.executedCommands.push(command);
+            return result;
         }
     }
-    executeAll() {
+    async executeAll() {
+        const results = [];
         while (this.commandQueue.length > 0) {
-            this.executeNext();
+            const result = await this.executeNext();
+            results.push(result);
         }
+        return results;
     }
     getQueueSize() {
         return this.commandQueue.length;
@@ -482,96 +514,104 @@ class CommandInvoker {
         return [...this.executedCommands];
     }
 }
-class AbstractVisualizationRunner {
-    run(array, strategyType) {
+exports.CommandInvoker = CommandInvoker;
+class AbstractSortingRunner {
+    async run(array, strategyType) {
         this.beforeRun();
-        const factory = new ConcreteVisualizationStrategyFactory();
+        const factory = new ConcreteSortingStrategyFactory();
         const strategy = factory.createStrategy(strategyType);
-        const builder = new VisualizerBuilder();
-        const visualizer = this.buildVisualizer(builder, array, strategy);
-        this.executeVisualization(visualizer);
+        const builder = new SorterBuilder();
+        const sorter = this.buildSorter(builder, array, strategy);
+        const result = await this.executeSorting(sorter);
         this.afterRun();
+        return result;
     }
-    buildVisualizer(builder, array, strategy) {
+    buildSorter(builder, array, strategy) {
         return builder
             .setArray(array)
             .setStrategy(strategy)
             .build();
     }
-    executeVisualization(visualizer) {
-        visualizer.execute();
+    async executeSorting(sorter) {
+        return await sorter.execute();
     }
 }
-class LoggingVisualizationRunner extends AbstractVisualizationRunner {
+exports.AbstractSortingRunner = AbstractSortingRunner;
+class LoggingSortingRunner extends AbstractSortingRunner {
     beforeRun() {
-        console.log('\n Starting visualization process...');
+        console.log('\n🚀 Starting sorting process...');
     }
     afterRun() {
-        console.log('\n Visualization process completed.');
+        console.log('\n✅ Sorting process completed.');
     }
 }
-function demonstrateVisualization() {
+exports.LoggingSortingRunner = LoggingSortingRunner;
+async function demonstrateSorting() {
     ConfigurationManager.getInstance().updateConfig({
         enableLogging: true,
-        logPrefix: '>',
+        logPrefix: '> ',
         showTimestamps: false
     });
     console.log('\n' + '='.repeat(70));
-    console.log('ARRAY VISUALIZATION FRAMEWORK');
-    console.log('  Using setTimeout + forEach Strategy');
+    console.log('🎨 ARRAY SORTING USING');
     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 numbers = [3, 1, 4, 1, 5, 9, 2, 6];
+    const sortableArray = numbers.map(n => new SortableNumber(n));
+    console.log(`\n📥 Input array: [${numbers.join(', ')}]`);
+    const factory = new ConcreteSortingStrategyFactory();
+    const strategy = factory.createStrategy(StrategyType.DEFAULT);
     const statisticsObserver = new StatisticsObserver();
     const historyObserver = new HistoryObserver();
-    const builder = new VisualizerBuilder();
-    const visualizer = builder
-        .setArray(visualizableArray)
+    const builder = new SorterBuilder();
+    const sorter = builder
+        .setArray(sortableArray)
         .setStrategy(strategy)
         .addObserver(statisticsObserver)
         .addObserver(historyObserver)
         .build();
     const invoker = new CommandInvoker();
-    const visualizationCommand = new ExecuteVisualizationCommand(visualizer);
-    invoker.enqueueCommand(visualizationCommand);
-    invoker.executeAll();
+    const sortingCommand = new ExecuteSortingCommand(sorter);
+    invoker.enqueueCommand(sortingCommand);
+    const results = await invoker.executeAll();
+    const sortedArray = results[0];
+    console.log('\n' + '─'.repeat(70));
+    console.log(`\n📊 Final sorted array: [${sortedArray.map(x => x.getValue()).join(', ')}]`);
     setTimeout(() => {
         console.log('\n' + '─'.repeat(70));
         statisticsObserver.printStatistics();
         historyObserver.printHistory();
         console.log('\n' + '='.repeat(70));
-        console.log('DEMONSTRATION COMPLETED');
+        console.log('✅ DEMONSTRATION COMPLETED');
         console.log('='.repeat(70) + '\n');
-    }, 5000);
+    }, 100);
 }
-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);
+async function demonstrateWithTemplateMethod() {
+    const numbers = [5, 2, 8, 1, 9];
+    const sortableArray = numbers.map(n => new SortableNumber(n));
+    const runner = new LoggingSortingRunner();
+    const sortedArray = await runner.run(sortableArray, StrategyType.DEFAULT);
+    console.log(`\n✅ Template Method result: [${sortedArray.map(x => x.getValue()).join(', ')}]`);
 }
-function demonstrateWithCustomConfig() {
-    const numbers = [100, 200, 300];
-    const visualizableArray = numbers.map(n => new VisualizableNumber(n));
+async function demonstrateWithCustomConfig() {
+    const numbers = [10, 5, 15, 3, 20];
+    const sortableArray = numbers.map(n => new SortableNumber(n));
     const invoker = new CommandInvoker();
     const configCommand = new UpdateConfigCommand({
-        logPrefix: '[TIMEOUT_FOREACH FRAMEWORK] ',
+        logPrefix: '[SLEEP SORT] ',
         showTimestamps: true
     });
     invoker.enqueueCommand(configCommand);
-    const factory = new ConcreteVisualizationStrategyFactory();
-    const strategy = factory.createStrategy(StrategyType.TIMEOUT_FOREACH);
-    const visualizer = new VisualizerBuilder()
-        .setArray(visualizableArray)
+    const factory = new ConcreteSortingStrategyFactory();
+    const strategy = factory.createStrategy(StrategyType.DEFAULT);
+    const sorter = new SorterBuilder()
+        .setArray(sortableArray)
         .setStrategy(strategy)
         .build();
-    const visualizationCommand = new ExecuteVisualizationCommand(visualizer);
-    invoker.enqueueCommand(visualizationCommand);
-    invoker.executeAll();
+    const sortingCommand = new ExecuteSortingCommand(sorter);
+    invoker.enqueueCommand(sortingCommand);
+    const results = await invoker.executeAll();
+    const sortedArray = results[1];
+    console.log(`\n✅ Custom config result: [${sortedArray.map(x => x.getValue()).join(', ')}]`);
 }
-console.log('\n Starting demonstration...\n');
-demonstrateVisualization();
+console.log('\n🎬 Starting demonstration...\n');
+demonstrateSorting();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "the-best-sort",
-  "version": "1.0.3",
+  "version": "1.2.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",
@@ -39,13 +39,13 @@
   "bugs": {
     "url": "https://github.com/danilasar/the-best-sort/issues"
   },
-  "homepage": "https://github.com/danilasar/the-best-sort#readme",
+  "homepage": "https://sort.danilasar.ru",
   "engines": {
     "node": ">=18.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
-    "typescript": "^5.3.0",
-    "tsx": "^4.20.6"
+    "tsx": "^4.20.6",
+    "typescript": "^5.3.0"
   }
 }