@routier/core 0.0.1-alpha.1 → 0.0.1-alpha.2

package/{src/pipeline/TrampolinePipeline.ts → dist/pipeline/index.js}

@@ -1,56 +1,83 @@
-import { CallbackResult, Result, ResultType } from "../results";
-
-/**
- * Type definition for an asynchronous function that takes data and a callback.
- * TIn: The input data type.
- * TOut: The output data type (passed to the callback).
- */
-export type Processor<TIn, TOut> = (data: TIn, callback: (result: TOut, error?: any) => void) => void;
-
-// Return type for a step execution: Either the next step function or null if waiting/done.
-type StepResult<TData> = TrampolineStep<TData> | null;
-type TrampolineStep<TData> = () => StepResult<TData>;
-
-export class TrampolinePipeline<TInitial, TCurrent = TInitial> {
-    private _list: Processor<any, any>[] = [];
-    private _hasErrored: boolean = false; // Flag to prevent calling done on error
+var __webpack_modules__ = ({
+"./src/pipeline/SyncronousQueue.ts": 
+/*!*****************************************!*\
+  !*** ./src/pipeline/SyncronousQueue.ts ***!
+  \*****************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  SyncronousQueue: () => (SyncronousQueue)
+});
+class SyncronousQueue {
+    _queue = [];
+    _current = null;
+    enqueue(unitOfWork) {
+        this._queue.push(unitOfWork);
+        this._next();
+    }
+    _next() {
+        if (this._current != null || this._queue.length === 0) {
+            return;
+        }
+        // Take first item
+        this._current = this._queue.shift() ?? null;
+        if (this._current == null) {
+            return;
+        }
+        this._current(() => {
+            this._current = null;
+            this._next();
+        });
+    }
+}
 
-    filter<TFinal>(initialData: TInitial, done: (data: TFinal, error?: any) => void) {
 
+}),
+"./src/pipeline/TrampolinePipeline.ts": 
+/*!********************************************!*\
+  !*** ./src/pipeline/TrampolinePipeline.ts ***!
+  \********************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  AsyncPipeline: () => (AsyncPipeline),
+  TrampolinePipeline: () => (TrampolinePipeline),
+  WorkPipeline: () => (WorkPipeline)
+});
+/* ESM import */var _results__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../results */ "./src/results/Result.ts");
+
+class TrampolinePipeline {
+    _list = [];
+    _hasErrored = false; // Flag to prevent calling done on error
+    filter(initialData, done) {
         this._hasErrored = false; // Reset error flag on new execution
-
         if (this._list.length === 0) {
-            queueMicrotask(() => done(initialData as any as TFinal));
+            queueMicrotask(() => done(initialData));
             return;
         }
-
         let index = 0;
-        let currentData: any = initialData;
+        let currentData = initialData;
         let isRunning = false; // Guard against overlapping trampoline calls
-
         try {
             // --- Revised Completion Logic --- (Moved up for clarity)
-            const finalStepSentinel = (): StepResult<any> => { // A special step function for the very end
+            const finalStepSentinel = () => {
                 // Only call done if no error has occurred
                 if (!this._hasErrored) {
-                    queueMicrotask(() => done(currentData as TFinal));
+                    queueMicrotask(() => done(currentData));
                 }
                 return null; // Stop the trampoline
             };
-
-            const createStepRevised = (idx: number): TrampolineStep<any> => {
+            const createStepRevised = (idx) => {
                 return () => {
-                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere
-
+                    if (this._hasErrored)
+                        return null; // Stop if an error occurred elsewhere
                     if (idx >= this._list.length) {
                         return finalStepSentinel(); // Execute the dedicated final step
                     }
-
                     const processor = this._list[idx];
                     // Initialize syncCallbackResult to null to satisfy StepResult type
-                    let syncCallbackResult: StepResult<any> = null;
+                    let syncCallbackResult = null;
                     let calledSync = false;
-
                     try {
                         processor(currentData, (result, error) => {
                             // --- Error Handling ---
@@ -61,22 +88,22 @@ export class TrampolinePipeline<TInitial, TCurrent = TInitial> {
                                 throw error;
                             }
                             // --- /Error Handling ---
-
                             // If no error, proceed as before
                             currentData = result;
                             index = idx + 1; // Update index for the next step
                             const nextStep = createStepRevised(index); // Use updated index
-
                             if (isRunning) {
                                 // Callback was synchronous
                                 syncCallbackResult = nextStep; // Store next step function
                                 calledSync = true;
-                            } else {
+                            }
+                            else {
                                 // Callback was asynchronous, restart trampoline
                                 trampoline(nextStep);
                             }
                         });
-                    } catch (error) {
+                    }
+                    catch (error) {
                         if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
                             console.error(`Error thrown by processor at index ${idx} or its callback:`, error);
                             this._hasErrored = true;
@@ -84,27 +111,23 @@ export class TrampolinePipeline<TInitial, TCurrent = TInitial> {
                         // Rethrow to be caught by the trampoline's catch block
                         throw error;
                     }
-
                     if (calledSync) {
                         // Return the next step function for the sync loop
                         return syncCallbackResult;
-                    } else {
+                    }
+                    else {
                         // Pause trampoline for async, loop will stop as step returns null
                         return null;
                     }
                 };
             };
-
             // The trampoline loop
-            const trampoline = (step: TrampolineStep<any> | null) => {
-
+            const trampoline = (step) => {
                 if (isRunning) {
                     return;
                 }
-
                 isRunning = true;
                 let currentStep = step;
-
                 while (typeof currentStep === 'function') {
                     try {
                         // Stop immediately if an error was flagged elsewhere
@@ -113,7 +136,8 @@ export class TrampolinePipeline<TInitial, TCurrent = TInitial> {
                             break;
                         }
                         currentStep = currentStep(); // Execute step, get next step or null
-                    } catch (trampolineError) {
+                    }
+                    catch (trampolineError) {
                         // Catch errors propagated from step execution (processor or callback errors)
                         if (!this._hasErrored) { // Avoid double logging
                             console.error("Error during trampoline step execution:", trampolineError);
@@ -127,102 +151,87 @@ export class TrampolinePipeline<TInitial, TCurrent = TInitial> {
                 }
                 // Loop ends when currentStep is null or loop is broken by error
                 isRunning = false;
-
                 // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
             };
-
             // --- Start the process ---
             index = 0; // Reset index
             currentData = initialData; // Reset data
             trampoline(createStepRevised(0)); // Start with the revised step creator
-        } catch (error: any) {
+        }
+        catch (error) {
             done(currentData, error);
         }
     }
-
-    pipe<TNext>(processor: Processor<TCurrent, TNext>) {
+    pipe(processor) {
         this._list.push(processor);
-        return this as unknown as TrampolinePipeline<TInitial, TNext>;
+        return this;
     }
-
-    pipeEach(items: TCurrent[], fn: (payload: ResultType<TCurrent>, done: CallbackResult<TCurrent>) => void, map: (previous: ResultType<TCurrent>, current: ResultType<TCurrent>) => ResultType<TCurrent>) {
+    pipeEach(items, fn, map) {
         for (let i = 0, length = items.length; i < length; i++) {
-
-            this.pipe<ResultType<TCurrent>>((previous, done) => {
-
-                fn(map(previous as ResultType<TCurrent>, Result.success(items[i])), done);
+            this.pipe((previous, done) => {
+                fn(map(previous, _results__WEBPACK_IMPORTED_MODULE_0__.Result.success(items[i])), done);
             });
         }
     }
 }
-
-export type AsyncUnitOfWork<TData, TResult> = (payload: TData, done: CallbackResult<TResult>) => void;
-export class AsyncPipeline<TData, TResult> {
-    private _list: [TData, AsyncUnitOfWork<TData, TResult>][] = [];
-    private _hasErrored: boolean = false; // Flag to prevent calling done on error
-
-    filter(done: CallbackResult<TResult[]>) {
-
+class AsyncPipeline {
+    _list = [];
+    _hasErrored = false; // Flag to prevent calling done on error
+    filter(done) {
         this._hasErrored = false; // Reset error flag on new execution
-        let currentData: TResult[] = [];
-
+        let currentData = [];
         if (this._list.length === 0) {
-            queueMicrotask(() => done(Result.success()));
+            queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success()));
             return;
         }
-
         let index = 0;
         let isRunning = false; // Guard against overlapping trampoline calls
-
         try {
             // --- Revised Completion Logic --- (Moved up for clarity)
-            const finalStepSentinel = (): StepResult<any> => { // A special step function for the very end
+            const finalStepSentinel = () => {
                 // Only call done if no error has occurred
                 if (!this._hasErrored) {
-                    queueMicrotask(() => done(Result.success(currentData)));
+                    queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success(currentData)));
                 }
                 return null; // Stop the trampoline
             };
-
-            const createStepRevised = (idx: number): TrampolineStep<any> => {
+            const createStepRevised = (idx) => {
                 return () => {
-                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere
-
+                    if (this._hasErrored)
+                        return null; // Stop if an error occurred elsewhere
                     if (idx >= this._list.length) {
                         return finalStepSentinel(); // Execute the dedicated final step
                     }
-
                     const [payload, processor] = this._list[idx];
                     // Initialize syncCallbackResult to null to satisfy StepResult type
-                    let syncCallbackResult: StepResult<any> = null;
+                    let syncCallbackResult = null;
                     let calledSync = false;
-
                     try {
                         processor(payload, (result) => {
                             // --- Error Handling ---
-                            if (result.ok === Result.ERROR) {
+                            if (result.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
                                 console.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);
                                 this._hasErrored = true; // Set flag
                                 // Throw the error to be caught by outer try...catch blocks
                                 throw result.error;
                             }
                             // --- /Error Handling ---
-
                             // If no error, proceed as before
                             currentData.push(result.data);
                             index = idx + 1; // Update index for the next step
                             const nextStep = createStepRevised(index); // Use updated index
-
                             if (isRunning) {
                                 // Callback was synchronous
                                 syncCallbackResult = nextStep; // Store next step function
                                 calledSync = true;
-                            } else {
+                            }
+                            else {
                                 // Callback was asynchronous, restart trampoline
                                 trampoline(nextStep);
                             }
                         });
-                    } catch (error) {
+                    }
+                    catch (error) {
                         if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
                             console.error(`Error thrown by processor at index ${idx} or its callback:`, error);
                             this._hasErrored = true;
@@ -230,27 +239,23 @@ export class AsyncPipeline<TData, TResult> {
                         // Rethrow to be caught by the trampoline's catch block
                         throw error;
                     }
-
                     if (calledSync) {
                         // Return the next step function for the sync loop
                         return syncCallbackResult;
-                    } else {
+                    }
+                    else {
                         // Pause trampoline for async, loop will stop as step returns null
                         return null;
                     }
                 };
             };
-
             // The trampoline loop
-            const trampoline = (step: TrampolineStep<any> | null) => {
-
+            const trampoline = (step) => {
                 if (isRunning) {
                     return;
                 }
-
                 isRunning = true;
                 let currentStep = step;
-
                 while (typeof currentStep === 'function') {
                     try {
                         // Stop immediately if an error was flagged elsewhere
@@ -259,7 +264,8 @@ export class AsyncPipeline<TData, TResult> {
                             break;
                         }
                         currentStep = currentStep(); // Execute step, get next step or null
-                    } catch (trampolineError) {
+                    }
+                    catch (trampolineError) {
                         // Catch errors propagated from step execution (processor or callback errors)
                         if (!this._hasErrored) { // Avoid double logging
                             console.error("Error during trampoline step execution:", trampolineError);
@@ -273,102 +279,88 @@ export class AsyncPipeline<TData, TResult> {
                 }
                 // Loop ends when currentStep is null or loop is broken by error
                 isRunning = false;
-
                 // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
             };
-
             // --- Start the process ---
             index = 0; // Reset index
             trampoline(createStepRevised(0)); // Start with the revised step creator
-        } catch (error: any) {
-            done(Result.error(error));
+        }
+        catch (error) {
+            done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.error(error));
         }
     }
-
-    pipe(data: TData, processor: AsyncUnitOfWork<TData, TResult>) {
+    pipe(data, processor) {
         this._list.push([data, processor]);
     }
-
-    pipeEach(items: TData[], processor: AsyncUnitOfWork<TData, TResult>) {
+    pipeEach(items, processor) {
         for (let i = 0, length = items.length; i < length; i++) {
             this.pipe(items[i], processor);
         }
     }
 }
-
-export type UnitOfWork = (done: CallbackResult<never>) => void;
-
 /**
  * Processes functions with callbacks asynchronously.
- * 
+ *
  * This pipeline handles work items that contain callback functions,
  * executing them in an asynchronous manner while maintaining proper
  * flow control and error handling.
  */
-export class WorkPipeline {
-    private unitsOfWork: UnitOfWork[] = [];
-    private _hasErrored: boolean = false; // Flag to prevent calling done on error
-
-    filter(done: CallbackResult<never>) {
-
+class WorkPipeline {
+    unitsOfWork = [];
+    _hasErrored = false; // Flag to prevent calling done on error
+    filter(done) {
         this._hasErrored = false; // Reset error flag on new execution
-
         if (this.unitsOfWork.length === 0) {
-            queueMicrotask(() => done(Result.success()));
+            queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success()));
             return;
         }
-
         let index = 0;
         let isRunning = false; // Guard against overlapping trampoline calls
-
         try {
             // --- Revised Completion Logic --- (Moved up for clarity)
-            const finalStepSentinel = (): StepResult<never> => { // A special step function for the very end
+            const finalStepSentinel = () => {
                 // Only call done if no error has occurred
                 if (!this._hasErrored) {
-                    queueMicrotask(() => done(Result.success()));
+                    queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success()));
                 }
                 return null; // Stop the trampoline
             };
-
-            const createStepRevised = (idx: number): TrampolineStep<any> => {
+            const createStepRevised = (idx) => {
                 return () => {
-                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere
-
+                    if (this._hasErrored)
+                        return null; // Stop if an error occurred elsewhere
                     if (idx >= this.unitsOfWork.length) {
                         return finalStepSentinel(); // Execute the dedicated final step
                     }
-
                     const processor = this.unitsOfWork[idx];
                     // Initialize syncCallbackResult to null to satisfy StepResult type
-                    let syncCallbackResult: StepResult<any> = null;
+                    let syncCallbackResult = null;
                     let calledSync = false;
-
                     try {
                         processor((result) => {
                             // --- Error Handling ---
-                            if (result.ok === Result.ERROR) {
+                            if (result.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
                                 console.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);
                                 this._hasErrored = true; // Set flag
                                 // Throw the error to be caught by outer try...catch blocks
                                 throw result.error;
                             }
                             // --- /Error Handling ---
-
                             // If no error, proceed as before
                             index = idx + 1; // Update index for the next step
                             const nextStep = createStepRevised(index); // Use updated index
-
                             if (isRunning) {
                                 // Callback was synchronous
                                 syncCallbackResult = nextStep; // Store next step function
                                 calledSync = true;
-                            } else {
+                            }
+                            else {
                                 // Callback was asynchronous, restart trampoline
                                 trampoline(nextStep);
                             }
                         });
-                    } catch (error) {
+                    }
+                    catch (error) {
                         if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
                             console.error(`Error thrown by processor at index ${idx} or its callback:`, error);
                             this._hasErrored = true;
@@ -376,27 +368,23 @@ export class WorkPipeline {
                         // Rethrow to be caught by the trampoline's catch block
                         throw error;
                     }
-
                     if (calledSync) {
                         // Return the next step function for the sync loop
                         return syncCallbackResult;
-                    } else {
+                    }
+                    else {
                         // Pause trampoline for async, loop will stop as step returns null
                         return null;
                     }
                 };
             };
-
             // The trampoline loop
-            const trampoline = (step: TrampolineStep<any> | null) => {
-
+            const trampoline = (step) => {
                 if (isRunning) {
                     return;
                 }
-
                 isRunning = true;
                 let currentStep = step;
-
                 while (typeof currentStep === 'function') {
                     try {
                         // Stop immediately if an error was flagged elsewhere
@@ -405,7 +393,8 @@ export class WorkPipeline {
                             break;
                         }
                         currentStep = currentStep(); // Execute step, get next step or null
-                    } catch (trampolineError) {
+                    }
+                    catch (trampolineError) {
                         // Catch errors propagated from step execution (processor or callback errors)
                         if (!this._hasErrored) { // Avoid double logging
                             console.error("Error during trampoline step execution:", trampolineError);
@@ -419,19 +408,187 @@ export class WorkPipeline {
                 }
                 // Loop ends when currentStep is null or loop is broken by error
                 isRunning = false;
-
                 // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
             };
-
             // --- Start the process ---
             index = 0; // Reset index
             trampoline(createStepRevised(0)); // Start with the revised step creator
-        } catch (error: any) {
-            done(Result.error(error));
+        }
+        catch (error) {
+            done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.error(error));
         }
     }
-
-    pipe(work: UnitOfWork) {
+    pipe(work) {
         this.unitsOfWork.push(work);
     }
 }
+
+
+}),
+"./src/results/Result.ts": 
+/*!*******************************!*\
+  !*** ./src/results/Result.ts ***!
+  \*******************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  PluginEventResult: () => (PluginEventResult),
+  Result: () => (Result)
+});
+class BaseResult {
+    static ERROR = "error";
+    static SUCCESS = "success";
+    static PARTIAL = "partial";
+    static resolve(result, resolve, reject) {
+        if (result.ok === BaseResult.SUCCESS) {
+            resolve(result.data);
+            return;
+        }
+        if (result.ok === BaseResult.PARTIAL) {
+            reject({
+                partial: result.data,
+                error: result.error
+            });
+            return;
+        }
+        reject(result.error);
+    }
+    static assertSuccess(result) {
+        if (result.ok !== BaseResult.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+class Result extends BaseResult {
+    static success(data) {
+        return {
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(error) {
+        return {
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(data, error) {
+        return {
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+}
+class PluginEventResult extends BaseResult {
+    static success(id, data) {
+        return {
+            id,
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(id, error) {
+        return {
+            id,
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(id, data, error) {
+        return {
+            id,
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+    static assertSuccess(result) {
+        if (result.ok !== Result.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+
+
+}),
+
+});
+/************************************************************************/
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+/************************************************************************/
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+
+/*!*******************************!*\
+  !*** ./src/pipeline/index.ts ***!
+  \*******************************/
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  AsyncPipeline: () => (/* reexport safe */ _TrampolinePipeline__WEBPACK_IMPORTED_MODULE_1__.AsyncPipeline),
+  SyncronousQueue: () => (/* reexport safe */ _SyncronousQueue__WEBPACK_IMPORTED_MODULE_0__.SyncronousQueue),
+  TrampolinePipeline: () => (/* reexport safe */ _TrampolinePipeline__WEBPACK_IMPORTED_MODULE_1__.TrampolinePipeline),
+  WorkPipeline: () => (/* reexport safe */ _TrampolinePipeline__WEBPACK_IMPORTED_MODULE_1__.WorkPipeline)
+});
+/* ESM import */var _SyncronousQueue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./SyncronousQueue */ "./src/pipeline/SyncronousQueue.ts");
+/* ESM import */var _TrampolinePipeline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./TrampolinePipeline */ "./src/pipeline/TrampolinePipeline.ts");
+
+
+
+})();
+
+var __webpack_exports__AsyncPipeline = __webpack_exports__.AsyncPipeline;
+var __webpack_exports__SyncronousQueue = __webpack_exports__.SyncronousQueue;
+var __webpack_exports__TrampolinePipeline = __webpack_exports__.TrampolinePipeline;
+var __webpack_exports__WorkPipeline = __webpack_exports__.WorkPipeline;
+export { __webpack_exports__AsyncPipeline as AsyncPipeline, __webpack_exports__SyncronousQueue as SyncronousQueue, __webpack_exports__TrampolinePipeline as TrampolinePipeline, __webpack_exports__WorkPipeline as WorkPipeline };
+
+//# sourceMappingURL=index.js.map