@maxdrellin/xenocline 0.0.1 → 0.0.3

package/.doccident-setup.mjs

@@ -0,0 +1,36 @@
+/* eslint-disable no-console */
+import { transform } from '@babel/core';
+// eslint-disable-next-line import/extensions
+import * as Xenocline from './dist/xenocline.js';
+
+export default {
+    "globals": {
+        "exports": {
+            "Xenocline": Xenocline
+        },
+        "console": {
+            "log": console.log,
+            "error": console.error,
+            "warn": console.warn,
+            "info": console.info,
+            "debug": console.debug
+        }
+    },
+    "require": {
+        '@maxdrellin/xenocline': Xenocline
+    },
+    transformCode: (code) => {
+        // transform the code using @bable/preset-typescript
+        const transformedCode = transform(code, {
+            filename: 'test.ts',
+            presets: ['@babel/preset-typescript'],
+            plugins: [
+                '@babel/plugin-transform-typescript',
+                '@babel/plugin-transform-modules-commonjs'
+            ],
+            comments: true // Preserve comments
+        })?.code;
+
+        return transformedCode;
+    }
+}

package/dist/event/node.d.ts

@@ -26,7 +26,7 @@ export interface AggregatorNodeEvent<A extends AggregatorNode = AggregatorNode>
 }
 export declare const createAggregatorNodeEvent: <A extends AggregatorNode>(sourceId: string, stage: AggregatorNodeEventStage, aggregatorNode: A, data?: AggregatorEventData) => AggregatorNodeEvent<A>;
 export declare const isAggregatorNodeEvent: (item: any) => item is AggregatorNodeEvent;
-export type PhaseNodeEventStage = 'start' | 'end';
+export type PhaseNodeEventStage = 'start' | 'prepared' | 'processed' | 'end';
 export interface PhaseEventData extends EventData {
     input?: Input;
     output?: Output;

package/dist/execution/node.js

@@ -1,12 +1,12 @@
-import { executeAggregatorNode } from './aggregator.js';
-import { handleNextStep } from './next.js';
+import { createAggregatorNodeEvent, createPhaseNodeEvent } from '../event/node.js';
+import { createDecisionEvent } from '../event/transition.js';
 import { isAggregatorNode } from '../node/aggregatornode.js';
 import { isPhaseNode } from '../node/phasenode.js';
 import { isDecision } from '../transition/decision.js';
-import { createDecisionEvent } from '../event/transition.js';
+import { executeAggregatorNode } from './aggregator.js';
 import { dispatchEvent } from './event.js';
-import { createAggregatorNodeEvent, createPhaseNodeEvent } from '../event/node.js';
-import { createPhaseEvent } from '../event/phase.js';
+import { handleNextStep } from './next.js';
+import { executePhase } from './phase.js';
 
 async function executeNode(nodeId, input, state) {
     //console.log('[EXECUTE_NODE_RECURSIVE_START]', { nodeId, input, phaseResultsKeys: Object.keys(state.phaseResults), activeExecutionsKeys: Array.from(state.activeExecutions.keys()), aggregatorDeferredsKeys: Array.from(state.aggregatorDeferreds.keys()) });
@@ -57,11 +57,21 @@ async function executeNode(nodeId, input, state) {
                 dispatchEvent(state.eventState, createPhaseNodeEvent(nodeId, 'start', node, {
                     input
                 }), state.context);
-                dispatchEvent(state.eventState, createPhaseEvent(nodeId, 'start', node.phase, {
+                if (node.prepare) {
+                    const [preparedInput, preparedContext] = await node.prepare(input, state.context);
+                    input = preparedInput;
+                    state.context = preparedContext;
+                }
+                dispatchEvent(state.eventState, createPhaseNodeEvent(nodeId, 'prepared', node, {
                     input
                 }), state.context);
-                output = await node.phase.execute(input);
-                dispatchEvent(state.eventState, createPhaseEvent(nodeId, 'execute', node.phase, {
+                output = await executePhase(nodeId, node, input, state);
+                if (node.process) {
+                    const [processedOutput, processedContext] = await node.process(output, state.context);
+                    output = processedOutput;
+                    state.context = processedContext;
+                }
+                dispatchEvent(state.eventState, createPhaseNodeEvent(nodeId, 'processed', node, {
                     input,
                     output
                 }), state.context);

package/dist/execution/node.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"node.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/execution/phase.d.ts

@@ -0,0 +1,5 @@
+import { Input } from '../input';
+import { PhaseNode } from '../node/phasenode';
+import { Output } from '../output';
+import { ExecutionState } from './process';
+export declare function executePhase(nodeId: string, node: PhaseNode, input: Input, state: ExecutionState): Promise<Output>;

package/dist/execution/phase.js

@@ -0,0 +1,23 @@
+import { createPhaseEvent } from '../event/phase.js';
+import { dispatchEvent } from './event.js';
+
+async function executePhase(nodeId, node, input, state) {
+    dispatchEvent(state.eventState, createPhaseEvent(nodeId, 'start', node.phase, {
+        input
+    }), state.context);
+    if (node.phase.verify) {
+        const verifyResponse = await node.phase.verify(input);
+        if (!verifyResponse.verified) {
+            throw new Error(verifyResponse.messages.join('\n'));
+        }
+    }
+    const output = await node.phase.execute(input);
+    dispatchEvent(state.eventState, createPhaseEvent(nodeId, 'execute', node.phase, {
+        input,
+        output
+    }), state.context);
+    return output;
+}
+
+export { executePhase };
+//# sourceMappingURL=phase.js.map

package/dist/execution/phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node/phasenode.d.ts

@@ -4,16 +4,22 @@ import { Input } from '../input';
 import { Output } from '../output';
 import { Phase } from '../phase';
 import { Node } from './node';
+export type ProcessMethod<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<[O, C]>;
+export type PrepareMethod<I extends Input = Input, C extends Context = Context> = (input: I, context: C) => Promise<[I, C]>;
 export interface PhaseNode<I extends Input = Input, // Input to this phase instance
 O extends Output = Output> extends Node {
     type: 'phase';
     phase: Phase<I, O>;
+    prepare?: PrepareMethod;
+    process?: ProcessMethod;
 }
-export interface PhaseNodeOptions<O extends Output = Output, C extends Context = Context> {
+export interface PhaseNodeOptions<I extends Input = Input, O extends Output = Output, C extends Context = Context> {
     next?: Next<O, C>;
+    prepare?: PrepareMethod<I, C>;
+    process?: ProcessMethod<O, C>;
 }
-export declare const DEFAULT_PHASE_NODE_OPTIONS: PhaseNodeOptions<Output, Context>;
-export declare const createPhaseNode: <I extends Input = Input, O extends Output = Output, C extends Context = Context>(id: string, phase: Phase<I, O>, options?: Partial<PhaseNodeOptions<O, C>>) => Readonly<PhaseNode<I, O>>;
+export declare const DEFAULT_PHASE_NODE_OPTIONS: PhaseNodeOptions<Input, Output, Context>;
+export declare const createPhaseNode: <I extends Input = Input, O extends Output = Output, C extends Context = Context>(id: string, phase: Phase<I, O>, options?: Partial<PhaseNodeOptions<I, O, C>>) => Readonly<PhaseNode<I, O>>;
 export declare const isPhaseNode: (obj: any) => obj is PhaseNode<any, any>;
 export declare const validatePhaseNode: (item: any, coordinates?: string[]) => Array<{
     coordinates: string[];

package/dist/node/phasenode.js

@@ -17,7 +17,9 @@ const createPhaseNode = (id, phase, options)=>{
         ...createNode('phase', id, {
             next: phaseNodeOptions.next
         }),
-        phase
+        phase,
+        prepare: phaseNodeOptions.prepare,
+        process: phaseNodeOptions.process
     };
 };
 const isPhaseNode = (obj)=>{

package/dist/node/phasenode.js.map

@@ -1 +1 @@
-{"version":3,"file":"phasenode.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"phasenode.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/phase.d.ts

@@ -1,12 +1,19 @@
 import { Input } from './input';
 import { Output } from './output';
+export interface VerifyMethodResponse {
+    verified: boolean;
+    messages: string[];
+}
+export type VerifyMethod<I extends Input = Input> = (input: I) => Promise<VerifyMethodResponse>;
 export type ExecuteMethod<T extends Input = Input, U extends Output = Output> = (input: T) => Promise<U>;
 export interface Phase<T extends Input = Input, U extends Output = Output> {
     name: string;
+    verify?: VerifyMethod<T>;
     execute: (input: T) => Promise<U>;
 }
 export interface PhaseOptions<T extends Input = Input, U extends Output = Output> {
     execute: ExecuteMethod<T, U>;
+    verify?: VerifyMethod<T>;
 }
 export declare const createPhase: <T extends Input = Input, U extends Output = Output>(name: string, options: Partial<PhaseOptions<T, U>>) => Readonly<Phase<T, U>>;
 export declare const isPhase: <T extends Input = Input, U extends Output = Output>(obj: any) => obj is Phase<T, U>;

package/dist/phase.js

@@ -12,7 +12,8 @@ const createPhase = (name, options)=>{
     };
     return {
         name,
-        execute: phaseOptions.execute
+        execute: phaseOptions.execute,
+        verify: phaseOptions.verify
     };
 };
 const isPhase = (obj)=>{

package/dist/phase.js.map

@@ -1 +1 @@
-{"version":3,"file":"phase.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"phase.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/xenocline.d.ts

@@ -58,10 +58,10 @@ export type { Input } from './input';
 export type { Node } from './node/node';
 export type { NodeEvent, NodeEventStage, AggregatorNodeEvent, PhaseNodeEvent } from './event/node';
 export type { Output } from './output';
-export type { Phase } from './phase';
+export type { Phase, VerifyMethod, VerifyMethodResponse, ExecuteMethod } from './phase';
 export type { PhaseEvent } from './event/phase';
 export type { PhaseEventStage } from './event/phase';
-export type { PhaseNode } from './node/phasenode';
+export type { PhaseNode, PrepareMethod, ProcessMethod } from './node/phasenode';
 export type { PhaseResults } from './execution/process';
 export type { Process } from './process';
 export type { ProcessEvent } from './event/process';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@maxdrellin/xenocline",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Xenocline provides a streamlined, modular framework to manage and execute Processor Pipelines—sequences of computational steps or tasks executed systematically to process data or events. It allows developers to define, connect, and orchestrate individual processors into efficient workflows, supporting clear separation of concerns, scalability, and ease of maintenance.",
-  "main": "dist/Xenocline.js",
+  "main": "dist/xenocline.js",
   "type": "module",
   "bin": {
     "Xenocline": "./dist/xenocline.js"
@@ -13,8 +13,8 @@
   },
   "exports": {
     ".": {
-      "import": "./dist/Xenocline.js",
-      "types": "./dist/Xenocline.d.ts"
+      "import": "./dist/xenocline.js",
+      "types": "./dist/xenocline.d.ts"
     }
   },
   "keywords": [
@@ -28,7 +28,7 @@
     "@doccident/doccident": "^0.0.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.27.1",
+    "@babel/core": "^7.27.3",
     "@babel/plugin-transform-modules-commonjs": "^7.27.1",
     "@babel/plugin-transform-typescript": "^7.27.1",
     "@babel/preset-typescript": "^7.27.1",
@@ -36,17 +36,17 @@
     "@eslint/js": "^9.27.0",
     "@jest/globals": "^29.7.0",
     "@rollup/plugin-replace": "^6.0.2",
-    "@swc/core": "^1.11.24",
+    "@swc/core": "^1.11.29",
     "@types/jest": "^29.5.14",
     "@types/js-yaml": "^4.0.9",
     "@types/luxon": "^3.6.2",
-    "@types/node": "^22.15.19",
+    "@types/node": "^22.15.21",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",
     "copyfiles": "^2.4.1",
     "eslint": "^9.27.0",
     "eslint-plugin-import": "^2.31.0",
-    "globals": "^16.1.0",
+    "globals": "^16.2.0",
     "jest": "^29.7.0",
     "rollup-plugin-preserve-shebang": "^1.0.1",
     "rollup-plugin-visualizer": "^5.14.0",
@@ -61,7 +61,7 @@
     "start": "node dist/Xenocline.js",
     "dev": "vite",
     "watch": "vite build --watch",
-    "test": "pnpm run test:coverage",
+    "test": "pnpm run test:coverage && pnpm run test:readme",
     "test:coverage": "jest --coverage",
     "test:readme": "doccident -c .doccident-setup.mjs README.md",
     "lint": "eslint . --ext .ts",