@maxdrellin/xenocline 0.0.1

package/dist/transition/transition.d.ts

@@ -0,0 +1,16 @@
+export type TransitionType = 'connection' | 'decision' | 'termination' | 'beginning';
+/**
+ * Base interface for transitions between nodes in a process.
+ * It is primarily a marker interface that allows Connection,
+ * Decision and Termination to share common generics.
+ */
+export interface Transition {
+    id: string;
+    type: TransitionType;
+}
+export declare const createTransition: (type: TransitionType, id: string) => Readonly<Transition>;
+export declare const isTransition: (item: any) => item is Transition;
+export declare const validateTransition: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/transition/transition.js

@@ -0,0 +1,72 @@
+const createTransition = (type, id)=>{
+    return {
+        id,
+        type
+    };
+};
+const isTransition = (item)=>{
+    return item !== null && typeof item === 'object' && typeof item.id === 'string' && (item.type === 'connection' || item.type === 'decision' || item.type === 'termination' || item.type === 'beginning');
+};
+const validateTransition = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || [],
+        'Transition'
+    ];
+    if (item === undefined || item === null) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Transition is undefined or null.'
+        });
+        return errors;
+    }
+    if (typeof item !== 'object') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Transition is not an object.'
+        });
+        return errors;
+    }
+    if (item.id === undefined || typeof item.id !== 'string') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Transition id is undefined or not a string.'
+        });
+    }
+    if (item.type === undefined || typeof item.type !== 'string') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Transition type is undefined or not a string.'
+        });
+    }
+    if (item.type !== 'connection' && item.type !== 'decision' && item.type !== 'termination' && item.type !== 'beginning') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Transition type is not a valid type.'
+        });
+    }
+    // We have an id, push to current coordinates
+    currentCoordinates.push(`Transition: ${item.id}`);
+    if (item.type === undefined || typeof item.type !== 'string') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Transition type is undefined or not a string.'
+        });
+    }
+    return errors;
+};
+
+export { createTransition, isTransition, validateTransition };
+//# sourceMappingURL=transition.js.map

package/dist/transition/transition.js.map

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

package/dist/util/general.d.ts

@@ -0,0 +1,4 @@
+export declare const clean: (obj: any) => {
+    [k: string]: unknown;
+};
+export declare const stringifyJSON: (obj: any, visited?: Set<any>) => string;

package/dist/util/general.js

@@ -0,0 +1,6 @@
+const clean = (obj)=>{
+    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
+};
+
+export { clean };
+//# sourceMappingURL=general.js.map

package/dist/util/general.js.map

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

package/dist/utility/event/eventfilter.d.ts

@@ -0,0 +1,7 @@
+import { Event } from '../../event/event';
+export interface EventFilter<E extends Event = Event> {
+    type?: string[];
+    stage?: string[];
+    filter: (event: E) => boolean;
+}
+export declare const createEventFilter: <E extends Event = Event>(type?: string[], stage?: string[]) => EventFilter<E>;

package/dist/utility/event/eventfilter.js

@@ -0,0 +1,15 @@
+const createEventFilter = (type, stage)=>{
+    const filterFn = (event)=>{
+        const typeMatch = !type || type.includes(event.type);
+        const stageMatch = !stage || stage.includes(event.stage);
+        return typeMatch && stageMatch;
+    };
+    return {
+        type,
+        stage,
+        filter: filterFn
+    };
+};
+
+export { createEventFilter };
+//# sourceMappingURL=eventfilter.js.map

package/dist/utility/event/eventfilter.js.map

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

package/dist/utility/event/filteredhandler.d.ts

@@ -0,0 +1,13 @@
+import { Event } from '../../event/event';
+import { Context } from '../../context';
+import { EventHandler, HandleMethod } from '../../event/handler';
+import { EventFilter } from './eventfilter';
+export interface FilteredHandler<E extends Event = Event, C extends Context = Context> extends EventHandler<E, C> {
+    filter: EventFilter<E>;
+    handler: EventHandler<E, C>;
+}
+export declare const createFilteredHandler: <E extends Event = Event, C extends Context = Context>(filter: EventFilter<E>, options: {
+    handler: EventHandler<E, C>;
+} | {
+    handle: HandleMethod<E, C>;
+}) => FilteredHandler<E, C>;

package/dist/utility/event/filteredhandler.js

@@ -0,0 +1,18 @@
+import { createEventHandler } from '../../event/handler.js';
+
+const createFilteredHandler = (filter, options)=>{
+    const handler = 'handler' in options ? options.handler : createEventHandler(options.handle);
+    const handle = async (event, context)=>{
+        if (filter.filter(event)) {
+            await handler.handle(event, context);
+        }
+    };
+    return {
+        filter,
+        handler,
+        handle
+    };
+};
+
+export { createFilteredHandler };
+//# sourceMappingURL=filteredhandler.js.map

package/dist/utility/event/filteredhandler.js.map

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

package/dist/utility/event/logginghandler.d.ts

@@ -0,0 +1,12 @@
+import { Logger, LogLevel } from '../../logger';
+import { Event } from '../../event/event';
+import { EventHandler } from '../../event/handler';
+import { Context } from '../../context';
+export type EventLogFunction<T extends Event, C extends Context> = (event: T, context: C) => [message: string, ...args: any[]];
+export type LoggingHandler<T extends Event, C extends Context> = EventHandler<T, C>;
+export interface LoggingHandlerOptions {
+    level: LogLevel;
+    context: string;
+    log: EventLogFunction<any, any>;
+}
+export declare const createLoggingHandler: <T extends Event, C extends Context>(logger: Logger, options: Partial<LoggingHandlerOptions>) => LoggingHandler<T, C>;

package/dist/xenocline.d.ts

@@ -0,0 +1,72 @@
+export { createAggregator } from './aggregator';
+export { createAggregatorEvent } from './event/aggregator';
+export { createAggregatorNode } from './node/aggregatornode';
+export { createBeginning } from './transition/beginning';
+export { createBeginningEvent } from './event/transition';
+export { createConnection } from './transition/connection';
+export { createConnectionEvent } from './event/transition';
+export { createDecision } from './transition/decision';
+export { createDecisionEvent } from './event/transition';
+export { createEventHandler } from './event/handler';
+export { createEventFilter } from './utility/event/eventfilter';
+export { createFilteredHandler } from './utility/event/filteredhandler';
+export { createEventState, dispatchEvent } from './execution/event';
+export { createNode, validateNode } from './node/node';
+export { createNodeEvent } from './event/node';
+export { createPhase } from './phase';
+export { createPhaseNode } from './node/phasenode';
+export { createProcess } from './process';
+export { createProcessEvent } from './event/process';
+export { createTermination } from './transition/termination';
+export { createTerminationEvent } from './event/transition';
+export { createTransitionEvent } from './event/transition';
+export { executeProcess } from './execution/process';
+export { isAggregator } from './aggregator';
+export { isAggregatorEvent } from './event/aggregator';
+export { isAggregatorNode } from './node/aggregatornode';
+export { isAggregatorNodeEvent } from './event/node';
+export { isBeginning } from './transition/beginning';
+export { isBeginningEvent } from './event/transition';
+export { isConnection } from './transition/connection';
+export { isConnectionEvent } from './event/transition';
+export { isDecision } from './transition/decision';
+export { isDecisionEvent } from './event/transition';
+export { isNode } from './node/node';
+export { isNodeEvent } from './event/node';
+export { isPhase } from './phase';
+export { isPhaseNode } from './node/phasenode';
+export { isPhaseNodeEvent } from './event/node';
+export { isProcess } from './process';
+export { isProcessEvent } from './event/process';
+export { isTermination } from './transition/termination';
+export { isTerminationEvent } from './event/transition';
+export { isTransition } from './transition/transition';
+export type { Aggregator, AggregationResult } from './aggregator';
+export type { AggregatorEvent } from './event/aggregator';
+export type { AggregatorEventStage } from './event/aggregator';
+export type { AggregatorNode } from './node/aggregatornode';
+export type { Beginning } from './transition/beginning';
+export type { Connection } from './transition/connection';
+export type { Context } from './context';
+export type { Decision } from './transition/decision';
+export type { Event } from './event/event';
+export type { EventHandler } from './event/handler';
+export type { EventState } from './execution/event';
+export type { EventFilter } from './utility/event/eventfilter';
+export type { FilteredHandler } from './utility/event/filteredhandler';
+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 { PhaseEvent } from './event/phase';
+export type { PhaseEventStage } from './event/phase';
+export type { PhaseNode } from './node/phasenode';
+export type { PhaseResults } from './execution/process';
+export type { Process } from './process';
+export type { ProcessEvent } from './event/process';
+export type { ProcessEventStage } from './event/process';
+export type { ProcessResults } from './execution/process';
+export type { Termination } from './transition/termination';
+export type { Transition } from './transition/transition';
+export type { TransitionEvent, TransitionEventStage, TransitionEventType, ConnectionEvent, DecisionEvent, TerminationEvent, BeginningEvent } from './event/transition';

package/dist/xenocline.js

@@ -0,0 +1,21 @@
+export { createAggregator, isAggregator } from './aggregator.js';
+export { createAggregatorEvent, isAggregatorEvent } from './event/aggregator.js';
+export { createAggregatorNode, isAggregatorNode } from './node/aggregatornode.js';
+export { createBeginning, isBeginning } from './transition/beginning.js';
+export { createBeginningEvent, createConnectionEvent, createDecisionEvent, createTerminationEvent, createTransitionEvent, isBeginningEvent, isConnectionEvent, isDecisionEvent, isTerminationEvent } from './event/transition.js';
+export { createConnection, isConnection } from './transition/connection.js';
+export { createDecision, isDecision } from './transition/decision.js';
+export { createEventHandler } from './event/handler.js';
+export { createEventFilter } from './utility/event/eventfilter.js';
+export { createFilteredHandler } from './utility/event/filteredhandler.js';
+export { createEventState, dispatchEvent } from './execution/event.js';
+export { createNode, isNode, validateNode } from './node/node.js';
+export { createNodeEvent, isAggregatorNodeEvent, isNodeEvent, isPhaseNodeEvent } from './event/node.js';
+export { createPhase, isPhase } from './phase.js';
+export { createPhaseNode, isPhaseNode } from './node/phasenode.js';
+export { createProcess, isProcess } from './process.js';
+export { createProcessEvent, isProcessEvent } from './event/process.js';
+export { createTermination, isTermination } from './transition/termination.js';
+export { executeProcess } from './execution/process.js';
+export { isTransition } from './transition/transition.js';
+//# sourceMappingURL=xenocline.js.map

package/dist/xenocline.js.map

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

package/eslint.config.mjs

@@ -0,0 +1,82 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import importPlugin from "eslint-plugin-import";
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+});
+
+export default defineConfig([
+    globalIgnores([
+        "dist/**",
+        "node_modules/**",
+        "**/*.test.ts",
+    ]),
+    {
+        extends: compat.extends("eslint:recommended", "plugin:@typescript-eslint/recommended"),
+
+        plugins: {
+            "@typescript-eslint": typescriptEslint,
+            "import": importPlugin,
+        },
+
+        languageOptions: {
+            globals: {
+                ...globals.node,
+            },
+
+            parser: tsParser,
+            ecmaVersion: "latest",
+            sourceType: "module",
+        },
+
+        rules: {
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/explicit-function-return-type": "off",
+
+            "@typescript-eslint/no-unused-vars": ["warn", {
+                argsIgnorePattern: "^_",
+            }],
+
+            indent: ["error", 4, {
+                SwitchCase: 1,
+            }],
+
+            "import/extensions": ["error", "never", {
+                ignorePackages: true,
+                pattern: {
+                    "js": "never",
+                    "ts": "never",
+                    "d": "always"
+                }
+            }],
+
+            "import/no-extraneous-dependencies": ["error", {
+                devDependencies: true,
+                optionalDependencies: false,
+                peerDependencies: false,
+            }],
+
+            "no-console": ["error"],
+
+            "no-restricted-imports": ["error", {
+                paths: ["dayjs", "fs", "moment-timezone"],
+                patterns: [
+                    {
+                        group: ["src/**"],
+                        message: "Use absolute imports instead of relative imports"
+                    }
+                ]
+            }]
+        },
+    }]);

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@maxdrellin/xenocline",
+  "version": "0.0.1",
+  "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",
+  "type": "module",
+  "bin": {
+    "Xenocline": "./dist/xenocline.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maxdrellin/xenocline.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/Xenocline.js",
+      "types": "./dist/Xenocline.d.ts"
+    }
+  },
+  "keywords": [
+    "pipeline",
+    "execution",
+    "workflow"
+  ],
+  "author": "Max Drellin <maxdrellin@yahoo.com>",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@doccident/doccident": "^0.0.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.27.1",
+    "@babel/plugin-transform-modules-commonjs": "^7.27.1",
+    "@babel/plugin-transform-typescript": "^7.27.1",
+    "@babel/preset-typescript": "^7.27.1",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.27.0",
+    "@jest/globals": "^29.7.0",
+    "@rollup/plugin-replace": "^6.0.2",
+    "@swc/core": "^1.11.24",
+    "@types/jest": "^29.5.14",
+    "@types/js-yaml": "^4.0.9",
+    "@types/luxon": "^3.6.2",
+    "@types/node": "^22.15.19",
+    "@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",
+    "jest": "^29.7.0",
+    "rollup-plugin-preserve-shebang": "^1.0.1",
+    "rollup-plugin-visualizer": "^5.14.0",
+    "ts-jest": "^29.3.4",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-node": "^5.0.1"
+  },
+  "scripts": {
+    "build": "tsc --noEmit && vite build && copyfiles -u 1 \"src/**/*.md\" dist && copyfiles -u 1 \"src/**/*.yaml\" dist",
+    "start": "node dist/Xenocline.js",
+    "dev": "vite",
+    "watch": "vite build --watch",
+    "test": "pnpm run test:coverage",
+    "test:coverage": "jest --coverage",
+    "test:readme": "doccident -c .doccident-setup.mjs README.md",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "clean": "rm -rf dist"
+  }
+}