@ronaldroe/micro-flow 0.0.9

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Starkey Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,527 @@
+# Micro-Flow
+
+A lightweight, flexible workflow orchestration library for Node.js and browser environments. Build complex, sequential processes with ease using an intuitive API that supports conditional logic, flow control, event handling, and state management.
+
+## Features
+
+- 🚀 **Simple & Intuitive** - Easy-to-understand API for building workflows
+- 🔄 **Sequential Execution** - Run steps in order with automatic error handling
+- 🌿 **Conditional Logic** - Branch execution based on conditions
+- 🎯 **Flow Control** - Break, skip, or pause workflow execution
+- 📡 **Event-Driven** - Listen to workflow and step lifecycle events
+- 💾 **State Management** - Built-in global state with nested path access
+- 📢 **Cross-Tab/Worker Communication** - Broadcast messages between browser tabs/windows or between workers in your favorite JS runtime
+- 🌐 **Universal** - Works in backend runtimes like Node.js and all modern browsers
+- ⚡ **Minimal Dependencies** - Lightweight and simple
+- 🎨 **Framework Friendly** - Integrates seamlessly with React, Vue, your favorite framework and vanilla JS
+
+## Installation
+
+```bash
+npm install --save micro-flow
+```
+
+## Quick Start
+
+### Node.js Example
+
+```javascript
+import { Workflow, Step } from 'micro-flow';
+
+// Create a simple workflow
+const workflow = new Workflow({
+  name: 'data-processor',
+  steps: [
+    new Step({
+      name: 'fetch-data',
+      callable: async () => {
+        const response = await fetch('https://api.example.com/data');
+        return response.json();
+      }
+    }),
+    new Step({
+      name: 'process-data',
+      callable: async () => {
+        console.log('Processing data...');
+        return { processed: true };
+      }
+    }),
+    new Step({
+      name: 'save-results',
+      callable: async () => {
+        console.log('Saving results...');
+        return { saved: true };
+      }
+    })
+  ]
+});
+
+// Execute the workflow
+const result = await workflow.execute();
+console.log('Workflow complete!', result.results);
+```
+
+### Browser Example
+
+```javascript
+import { Workflow, Step } from './micro-flow.js';
+
+const workflow = new Workflow({
+  name: 'ui-update',
+  steps: [
+    new Step({
+      name: 'show-loading',
+      callable: async () => {
+        document.getElementById('loader').style.display = 'block';
+      }
+    }),
+    new Step({
+      name: 'fetch-data',
+      callable: async () => {
+        const response = await fetch('/api/data');
+        return response.json();
+      }
+    }),
+    new Step({
+      name: 'update-ui',
+      callable: async () => {
+        document.getElementById('content').textContent = 'Data loaded!';
+        document.getElementById('loader').style.display = 'none';
+      }
+    })
+  ]
+});
+
+document.getElementById('loadBtn').addEventListener('click', () => {
+  workflow.execute();
+});
+```
+
+### React Example
+
+```javascript
+import { Workflow, Step, State } from './micro-flow.js';
+import { useState } from 'react';
+
+function DataFetcher() {
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(false);
+
+  const fetchData = async () => {
+    const workflow = new Workflow({
+      name: 'fetch-workflow',
+      steps: [
+        new Step({
+          name: 'start',
+          callable: async () => {
+            setLoading(true);
+          }
+        }),
+        new Step({
+          name: 'fetch',
+          callable: async () => {
+            const res = await fetch('/api/data');
+            const json = await res.json();
+            setData(json);
+          }
+        }),
+        new Step({
+          name: 'complete',
+          callable: async () => {
+            setLoading(false);
+          }
+        })
+      ]
+    });
+
+    await workflow.execute();
+  };
+
+  return (
+    <div>
+      <button onClick={fetchData} disabled={loading}>
+        {loading ? 'Loading...' : 'Fetch Data'}
+      </button>
+      {data && <pre>{JSON.stringify(data, null, 2)}</pre>}
+    </div>
+  );
+}
+```
+
+### Vue Example
+
+```vue
+<template>
+  <div>
+    <button @click="runWorkflow" :disabled="isRunning">
+      {{ isRunning ? 'Processing...' : 'Run Workflow' }}
+    </button>
+    <p>{{ result }}</p>
+  </div>
+</template>
+
+<script setup>
+import { ref } from 'vue';
+import { Workflow, Step } from './micro-flow.js';
+
+const isRunning = ref(false);
+const result = ref('');
+
+const runWorkflow = async () => {
+  const workflow = new Workflow({
+    name: 'vue-workflow',
+    steps: [
+      new Step({
+        name: 'step-1',
+        callable: async () => {
+          isRunning.value = true;
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          return 'Step 1 complete';
+        }
+      }),
+      new Step({
+        name: 'step-2',
+        callable: async () => {
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          return 'Step 2 complete';
+        }
+      })
+    ]
+  });
+
+  const workflowResult = await workflow.execute();
+  result.value = 'Workflow complete!';
+  isRunning.value = false;
+};
+</script>
+```
+
+## Core Concepts
+
+### Workflows
+
+Workflows are primary structures that execute a series of steps in sequence. They provide:
+
+- Sequential step execution
+- Error handling with `exit_on_error` option
+- Pause and resume capabilities
+- Event emission for monitoring
+- Result collection
+
+```javascript
+import { Workflow } from 'micro-flow';
+
+const workflow = new Workflow({
+  name: 'my-workflow',
+  exit_on_error: true,  // Stop on first error
+  steps: [/* array of steps */]
+});
+```
+
+### Steps
+
+Steps are individual units of work that execute functions, other steps, or even entire workflows:
+
+```javascript
+import { Step } from 'micro-flow';
+
+const step = new Step({
+  name: 'my-step',
+  callable: async () => {
+    // Your async code here
+    return result;
+  }
+});
+```
+
+### Callables
+
+Most step types accept a `callable` parameter. Callables are the individual actions a step can take.
+
+A callable can be any async function, another step, or even a whole workflow. That flexibility allows for everything from very simple workflows to large, modularized flows broken down into logical units for execution.
+
+### State Management
+
+Access global state across all workflows and steps:
+
+```javascript
+import { State } from 'micro-flow';
+
+// Set values
+State.set('user.name', 'John Doe');
+State.set('config.timeout', 5000);
+
+// Get values
+const userName = State.get('user.name');
+const timeout = State.get('config.timeout', 3000); // with default
+
+// Delete values
+State.delete('user.name');
+
+// Merge objects into state
+State.merge({ settings: { theme: 'dark', lang: 'en' } });
+
+// Iterate over collections
+State.set('users', [{ name: 'Alice' }, { name: 'Bob' }]);
+State.each('users', (user, index) => {
+  console.log(`User ${index}: ${user.name}`);
+});
+
+// Freeze state (make immutable)
+State.freeze();
+
+// Reset state to defaults
+State.reset();
+```
+
+### Events
+
+Listen to workflow, step, and state lifecycle events. You can do this using Node's EventEmitter syntax or the browser's CustomEvent syntax. Both work in any environment:
+
+```javascript
+import { State } from 'micro-flow';
+
+const workflowEvents = State.get('events.workflow');
+
+workflowEvents.on('workflow_complete', (data) => {
+  console.log(`Workflow ${data.name} completed in ${data.timing.execution_time_ms}ms`);
+});
+
+const stepEvents = State.get('events.step');
+
+stepEvents.on('step_failed', (data) => {
+  console.error(`Step ${data.name} failed:`, data.errors);
+});
+
+const stateEvents = State.get('events.state');
+
+stateEvents.on('set', (data) => {
+  console.log('State modified:', data.state);
+});
+
+stateEvents.on('deleted', (data) => {
+  console.log('State property deleted');
+});
+```
+
+### Cross-Tab/Worker Communication
+
+Broadcast messages between browser tabs and windows or across workers in your favorite JS runtime:
+
+```javascript
+import { Broadcast } from './micro-flow.js';
+
+const broadcast = new Broadcast('my-channel');
+
+// Send messages to other tabs
+broadcast.send({ type: 'update', data: { userId: 123 } });
+
+// Receive messages from other tabs
+broadcast.onReceive((data) => {
+  console.log('Message from another tab:', data);
+  if (data.type === 'update') {
+    updateUI(data.data);
+  }
+});
+
+// Clean up when done
+broadcast.destroy();
+```
+
+## Use Cases
+
+### Backend (Node.js)
+
+- **Data Processing Pipelines** - ETL workflows, data transformation
+- **API Integrations** - Multi-step API calls with retry logic
+- **Task Automation** - Scheduled jobs, batch processing
+- **Microservices Orchestration** - Coordinate service calls
+- **Testing Workflows** - Integration test sequences
+
+### Frontend (Browser)
+
+- **Multi-Step Forms** - Registration, checkout, surveys
+- **Data Fetching** - Sequential API calls with caching
+- **Animation Sequences** - Complex UI animations
+- **User Onboarding** - Step-by-step tutorials
+- **State Machines** - UI state management
+- **Cross-Tab Synchronization** - Auth state, shopping cart, notifications
+- **Real-Time Collaboration** - Multi-tab editing, shared state
+
+## Advanced Examples
+
+### Node.js - Data Pipeline with Error Handling
+
+```javascript
+import { Workflow, Step, ConditionalStep, State } from 'micro-flow';
+
+const pipeline = new Workflow({
+  name: 'data-pipeline',
+  exit_on_error: false,
+  steps: [
+    new Step({
+      name: 'extract',
+      callable: async () => {
+        const data = await fetchFromDatabase();
+        State.set('pipeline.raw', data);
+        return data;
+      }
+    }),
+    new ConditionalStep({
+      name: 'validate',
+      conditional: {
+        subject: State.get('pipeline.raw')?.length,
+        operator: '>',
+        value: 0
+      },
+      true_callable: async () => ({ valid: true }),
+      false_callable: async () => {
+        throw new Error('No data to process');
+      }
+    }),
+    new Step({
+      name: 'transform',
+      callable: async () => {
+        const raw = State.get('pipeline.raw');
+        const transformed = raw.map(transform);
+        State.set('pipeline.transformed', transformed);
+        return transformed;
+      }
+    }),
+    new Step({
+      name: 'load',
+      callable: async () => {
+        const data = State.get('pipeline.transformed');
+        await saveToDatabase(data);
+        return { saved: data.length };
+      }
+    })
+  ]
+});
+
+await pipeline.execute();
+```
+
+### Browser - Multi-Step Form with Validation
+
+```javascript
+import { Workflow, ConditionalStep } from './micro-flow.js';
+
+function createFormWorkflow(formData) {
+  return new Workflow({
+    name: 'form-submission',
+    steps: [
+      new ConditionalStep({
+        name: 'validate-email',
+        conditional: {
+          subject: /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email),
+          operator: '===',
+          value: true
+        },
+        true_callable: async () => ({ valid: true }),
+        false_callable: async () => {
+          throw new Error('Invalid email');
+        }
+      }),
+      new Step({
+        name: 'submit',
+        callable: async () => {
+          const response = await fetch('/api/submit', {
+            method: 'POST',
+            body: JSON.stringify(formData)
+          });
+          return response.json();
+        }
+      }),
+      new Step({
+        name: 'show-success',
+        callable: async () => {
+          document.getElementById('message').textContent = 'Success!';
+        }
+      })
+    ]
+  });
+}
+```
+
+## Documentation
+
+Full documentation is available in the [docs](docs/) directory:
+
+- [API Documentation](docs/index.md) - Complete API reference
+- [Classes](docs/classes/) - Workflow, Step, State, and more
+- [Events](docs/classes/events/) - Event system documentation
+- [Enums](docs/enums/) - Status codes and constants
+- [Examples](docs/examples/) - Comprehensive examples
+
+### Quick Links
+
+**Core Classes:**
+- [Workflow API](docs/classes/workflow.md)
+- [Step API](docs/classes/steps/step.md)
+- [State Management](docs/classes/state.md)
+
+**Logic Steps:**
+- [LogicStep API](docs/classes/steps/logic_step.md)
+- [ConditionalStep API](docs/classes/steps/conditional_step.md)
+- [FlowControlStep API](docs/classes/steps/flow_control_step.md)
+- [CaseStep API](docs/classes/steps/case.md)
+- [SwitchStep API](docs/classes/steps/switch_step.md)
+- [LoopStep API](docs/classes/steps/loop_step.md)
+- [DelayStep API](docs/classes/steps/delay_step.md)
+
+**Events:**
+- [Event System](docs/classes/events/event.md)
+- [WorkflowEvent API](docs/classes/events/workflow_event.md)
+- [StepEvent API](docs/classes/events/step_event.md)
+- [StateEvent API](docs/classes/events/state_event.md)
+- [Broadcast API](docs/classes/events/broadcast.md)
+
+**Enumerations:**
+- [Base Types](docs/enums/base_types.md)
+- [Step Types](docs/enums/step_types.md)
+- [Sub Step Types](docs/enums/sub_step_types.md)
+- [Logic Step Types](docs/enums/logic_step_types.md)
+- [Conditional Step Comparators](docs/enums/conditional_step_comparators.md)
+- [Flow Control Types](docs/enums/flow_control_types.md)
+- [Step Statuses](docs/enums/step_statuses.md)
+- [Workflow Statuses](docs/enums/workflow_statuses.md)
+- [Step Event Names](docs/enums/step_event_names.md)
+- [Workflow Event Names](docs/enums/workflow_event_names.md)
+- [State Event Names](docs/enums/state_event_names.md)
+- [Delay Types](docs/enums/delay_types.md)
+- [Loop Types](docs/enums/loop_types.md)
+- [Errors and Warnings](docs/enums/errors.md)
+
+## Browser Compatibility
+
+Micro-flow works in all modern browsers that support:
+- ES6 Modules
+- Async/await
+- CustomEvent API
+- EventTarget API
+
+Supported browsers:
+- Chrome/Edge 63+
+- Firefox 60+
+- Safari 11.1+
+- Opera 50+
+
+## Node.js Compatibility
+
+Requires Node.js 14+ for full ES6 module support.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Why Micro-Flow?
+
+Micro-flow is designed to be:
+
+- **Lightweight** - Small footprint, minimal dependencies
+- **Simple** - Easy to learn and use
+- **Flexible** - Works in Node.js and browsers
+- **Powerful** - Handles complex workflows with ease
+
+Perfect for projects that need workflow orchestration without the complexity of enterprise solutions.

package/dist/index.js

@@ -0,0 +1,2 @@
+export*from"./src/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../index.js"],
+  "sourcesContent": ["export * from './src/index.js';\n"],
+  "mappings": "AAAA,WAAc",
+  "names": []
+}

package/dist/src/classes/base.js

@@ -0,0 +1,4 @@
+var h=Object.defineProperty;var a=(i,t)=>h(i,"name",{value:t,configurable:!0});import{v4 as p}from"uuid";import{base_types as o}from"../enums/index.js";import e from"./state.js";class r{static{a(this,"Base")}constructor({name:t,base_type:s=o.STEP}){this.id=p(),this.name=t??`${s}-${this.id}`,this.base_type=s,this.timing={cancel_time:null,complete_time:null,end_time:null,execution_time_ms:null,start_time:null}}async execute(){throw new Error("Execute method not implemented")}log(t,s=null){if(!t||!e.get(`events.${this.base_type}`))throw new Error("Invalid event name or event emitter not found");if(e.get(`events.${this.base_type}`).emit(t,this),e.get("log_suppress"))return;const n=s?`
+[${this.base_type.toUpperCase()} - ${this.name}] ${s}`:`
+[${this.base_type.toUpperCase()} - ${this.name}] Event: ${t}`,m=t.endsWith("_failed")?"error":"log";console[m](n)}markAsComplete(){this.timing.complete_time=new Date,this.status=e.get("statuses")[this.base_type].COMPLETE,this.timing.execution_time_ms=this.timing.complete_time-this.timing.start_time,this.steps_by_id&&delete this.steps_by_id,this.log(e.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_COMPLETE`],`${this.base_type.charAt(0).toUpperCase()+this.base_type.slice(1)} "${this.name}" complete.`)}markAsFailed(){this.timing.complete_time=new Date,this.status=e.get("statuses")[this.base_type].FAILED,this.timing.execution_time_ms=this.timing.complete_time-this.timing.start_time,this.log(e.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_FAILED`],`${this.base_type.charAt(0).toUpperCase()+this.base_type.slice(1)} "${this.name}" failed.`)}markAsWaiting(){}markAsPending(){}markAsRunning(){this.timing.start_time=new Date,this.status=e.get("statuses")[this.base_type].RUNNING,this.log(e.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_RUNNING`],`${this.base_type.charAt(0).toUpperCase()+this.base_type.slice(1)} "${this.name}" started.`)}getState(t){return e.get(t)}setState(t,s){e.set(t,s)}deleteState(t){e.delete(t)}}export{r as default};
+//# sourceMappingURL=base.js.map

package/dist/src/classes/base.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/classes/base.js"],
+  "sourcesContent": ["import { v4 as uuidv4 } from 'uuid';\nimport { base_types } from '../enums/index.js';\nimport State from './state.js';\n\n/**\n * Base class for workflows and steps.\n * Provides common functionality for timing, status management, logging, and state access.\n * @class Base\n */\nexport default class Base {\n  /**\n   * Creates a new Base instance.\n   * @param {Object} options - Configuration options.\n   * @param {string} [options.name] - Name of the instance.\n   * @param {string} [options.base_type=base_types.STEP] - Type of the base instance.\n   */\n  constructor({ name, base_type = base_types.STEP }) {\n    this.id = uuidv4();\n    this.name = name ?? `${base_type}-${this.id}`;\n\n    this.base_type = base_type;\n    this.timing = {\n      cancel_time: null,\n      complete_time: null,\n      end_time: null,\n      execution_time_ms: null,\n      start_time: null,\n    }\n  }\n\n  /**\n   * Executes the instance. Must be overridden by subclasses.\n   * @async\n   * @throws {Error} Throws if not implemented in subclass.\n   */\n  async execute() {\n    throw new Error('Execute method not implemented');\n  }\n\n  /**\n   * Logs an event and emits it to the appropriate event emitter.\n   * @param {string} event_name - Name of the event to log.\n   * @param {string} [message=null] - Optional message to log.\n   * @throws {Error} Throws if event name is invalid or event emitter not found.\n   */\n  log(event_name, message = null) {\n    if (!event_name || !State.get(`events.${this.base_type}`)) {\n      throw new Error('Invalid event name or event emitter not found');\n    }\n\n    State.get(`events.${this.base_type}`).emit(event_name, this);\n    if (State.get('log_suppress')) {\n      return;\n    }\n\n    const logMessage = message ? `\\n[${this.base_type.toUpperCase()} - ${this.name}] ${message}` : `\\n[${this.base_type.toUpperCase()} - ${this.name}] Event: ${event_name}`;\n    const logType = event_name.endsWith('_failed') ? 'error' : 'log';\n\n    console[logType](logMessage);\n  }\n\n  /**\n   * Marks the instance as complete and calculates execution time.\n   */\n  markAsComplete() {\n    this.timing.complete_time = new Date();\n    this.status = State.get('statuses')[this.base_type].COMPLETE;\n    this.timing.execution_time_ms = this.timing.complete_time - this.timing.start_time;\n\n    if (this.steps_by_id) {\n      delete this.steps_by_id;\n    }\n\n    this.log(\n      State.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_COMPLETE`],\n      `${this.base_type.charAt(0).toUpperCase() + this.base_type.slice(1)} \"${this.name}\" complete.`\n    );\n  }\n\n  /**\n   * Marks the instance as failed and calculates execution time.\n   */\n  markAsFailed() {\n    this.timing.complete_time = new Date();\n    this.status = State.get('statuses')[this.base_type].FAILED;\n    this.timing.execution_time_ms = this.timing.complete_time - this.timing.start_time;\n\n    this.log(\n      State.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_FAILED`],\n      `${this.base_type.charAt(0).toUpperCase() + this.base_type.slice(1)} \"${this.name}\" failed.`\n    );\n  }\n\n  /**\n   * Marks the instance as waiting. To be implemented by subclasses.\n   */\n  markAsWaiting() { }\n\n  /**\n   * Marks the instance as pending. To be implemented by subclasses.\n   */\n  markAsPending() { }\n\n  /**\n   * Marks the instance as running and sets the start time.\n   */\n  markAsRunning() {\n    this.timing.start_time = new Date();\n    this.status = State.get('statuses')[this.base_type].RUNNING;\n\n    this.log(\n      State.get(`event_names.${this.base_type}`)[`${this.base_type.toUpperCase()}_RUNNING`],\n      `${this.base_type.charAt(0).toUpperCase() + this.base_type.slice(1)} \"${this.name}\" started.`\n    );\n  }\n\n  // State management methods\n  /**\n   * Gets a value from the global state.\n   * @param {string} path - Path to the state property.\n   * @returns {*} The state value at the specified path.\n   */\n  getState(path) {\n    return State.get(path);\n  }\n\n  /**\n   * Sets a value in the global state.\n   * @param {string} path - Path to the state property.\n   * @param {*} value - Value to set.\n   */\n  setState(path, value) {\n    State.set(path, value);\n  }\n\n  /**\n   * Deletes a property from the global state.\n   * @param {string} path - Path to the state property to delete.\n   */\n  deleteState(path) {\n    State.delete(path);\n  }\n}\n"],
+  "mappings": "+EAAA,OAAS,MAAMA,MAAc,OAC7B,OAAS,cAAAC,MAAkB,oBAC3B,OAAOC,MAAW,aAOlB,MAAOC,CAAmB,CAT1B,MAS0B,CAAAC,EAAA,aAOxB,YAAY,CAAE,KAAAC,EAAM,UAAAC,EAAYL,EAAW,IAAK,EAAG,CACjD,KAAK,GAAKD,EAAO,EACjB,KAAK,KAAOK,GAAQ,GAAGC,CAAS,IAAI,KAAK,EAAE,GAE3C,KAAK,UAAYA,EACjB,KAAK,OAAS,CACZ,YAAa,KACb,cAAe,KACf,SAAU,KACV,kBAAmB,KACnB,WAAY,IACd,CACF,CAOA,MAAM,SAAU,CACd,MAAM,IAAI,MAAM,gCAAgC,CAClD,CAQA,IAAIC,EAAYC,EAAU,KAAM,CAC9B,GAAI,CAACD,GAAc,CAACL,EAAM,IAAI,UAAU,KAAK,SAAS,EAAE,EACtD,MAAM,IAAI,MAAM,+CAA+C,EAIjE,GADAA,EAAM,IAAI,UAAU,KAAK,SAAS,EAAE,EAAE,KAAKK,EAAY,IAAI,EACvDL,EAAM,IAAI,cAAc,EAC1B,OAGF,MAAMO,EAAaD,EAAU;AAAA,GAAM,KAAK,UAAU,YAAY,CAAC,MAAM,KAAK,IAAI,KAAKA,CAAO,GAAK;AAAA,GAAM,KAAK,UAAU,YAAY,CAAC,MAAM,KAAK,IAAI,YAAYD,CAAU,GAChKG,EAAUH,EAAW,SAAS,SAAS,EAAI,QAAU,MAE3D,QAAQG,CAAO,EAAED,CAAU,CAC7B,CAKA,gBAAiB,CACf,KAAK,OAAO,cAAgB,IAAI,KAChC,KAAK,OAASP,EAAM,IAAI,UAAU,EAAE,KAAK,SAAS,EAAE,SACpD,KAAK,OAAO,kBAAoB,KAAK,OAAO,cAAgB,KAAK,OAAO,WAEpE,KAAK,aACP,OAAO,KAAK,YAGd,KAAK,IACHA,EAAM,IAAI,eAAe,KAAK,SAAS,EAAE,EAAE,GAAG,KAAK,UAAU,YAAY,CAAC,WAAW,EACrF,GAAG,KAAK,UAAU,OAAO,CAAC,EAAE,YAAY,EAAI,KAAK,UAAU,MAAM,CAAC,CAAC,KAAK,KAAK,IAAI,aACnF,CACF,CAKA,cAAe,CACb,KAAK,OAAO,cAAgB,IAAI,KAChC,KAAK,OAASA,EAAM,IAAI,UAAU,EAAE,KAAK,SAAS,EAAE,OACpD,KAAK,OAAO,kBAAoB,KAAK,OAAO,cAAgB,KAAK,OAAO,WAExE,KAAK,IACHA,EAAM,IAAI,eAAe,KAAK,SAAS,EAAE,EAAE,GAAG,KAAK,UAAU,YAAY,CAAC,SAAS,EACnF,GAAG,KAAK,UAAU,OAAO,CAAC,EAAE,YAAY,EAAI,KAAK,UAAU,MAAM,CAAC,CAAC,KAAK,KAAK,IAAI,WACnF,CACF,CAKA,eAAgB,CAAE,CAKlB,eAAgB,CAAE,CAKlB,eAAgB,CACd,KAAK,OAAO,WAAa,IAAI,KAC7B,KAAK,OAASA,EAAM,IAAI,UAAU,EAAE,KAAK,SAAS,EAAE,QAEpD,KAAK,IACHA,EAAM,IAAI,eAAe,KAAK,SAAS,EAAE,EAAE,GAAG,KAAK,UAAU,YAAY,CAAC,UAAU,EACpF,GAAG,KAAK,UAAU,OAAO,CAAC,EAAE,YAAY,EAAI,KAAK,UAAU,MAAM,CAAC,CAAC,KAAK,KAAK,IAAI,YACnF,CACF,CAQA,SAASS,EAAM,CACb,OAAOT,EAAM,IAAIS,CAAI,CACvB,CAOA,SAASA,EAAMC,EAAO,CACpBV,EAAM,IAAIS,EAAMC,CAAK,CACvB,CAMA,YAAYD,EAAM,CAChBT,EAAM,OAAOS,CAAI,CACnB,CACF",
+  "names": ["uuidv4", "base_types", "State", "Base", "__name", "name", "base_type", "event_name", "message", "logMessage", "logType", "path", "value"]
+}

package/dist/src/classes/events/broadcast.js

@@ -0,0 +1,2 @@
+var o=Object.defineProperty;var t=(e,s)=>o(e,"name",{value:s,configurable:!0});class c extends BroadcastChannel{static{t(this,"Broadcast")}constructor(s){super(s)}send(s){this.postMessage(s)}onReceive(s){this.onmessage=a=>{s(a.data)}}destroy(){this.close()}}export{c as default};
+//# sourceMappingURL=broadcast.js.map

package/dist/src/classes/events/broadcast.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/classes/events/broadcast.js"],
+  "sourcesContent": ["/**\n * Broadcast class provides a simplified wrapper around the BroadcastChannel API\n * for cross-context communication (e.g., between tabs, windows, workers).\n * \n * This class allows you to send and receive messages across different browsing contexts\n * that share the same origin. It encapsulates the creation and management of a BroadcastChannel,\n * providing a simplified API for sending and receiving messages.\n * \n * @class Broadcast\n * @extends BroadcastChannel\n */\nexport default class Broadcast extends BroadcastChannel {\n  /**\n   * Creates a new Broadcast instance for a named channel.\n   * \n   * @constructor\n   * @param {string} channelName - The name of the broadcast channel to create or connect to.\n   * Multiple Broadcast instances with the same channel name can communicate with each other.\n   */\n  constructor(channelName) {\n    super(channelName);\n  }\n\n  /**\n   * Sends data to all other contexts listening on this channel.\n   * \n   * @param {*} data - The data to broadcast. Can be any structured-cloneable value\n   * (primitives, objects, arrays, etc.). Functions and DOM nodes cannot be sent.\n   * @returns {void}\n   */\n  send(data) {\n    this.postMessage(data);\n  }\n\n  /**\n   * Registers a callback to handle incoming messages on this channel.\n   * \n   * @param {Function} callback - Function to call when a message is received.\n   * Receives the message data as its only parameter.\n   * @returns {void}\n   */\n  onReceive(callback) {\n    this.onmessage = (event) => {\n      callback(event.data);\n    };\n  }\n\n  /**\n   * Closes the broadcast channel and releases its resources.\n   * After calling this method, the Broadcast instance can no longer send or receive messages.\n   * \n   * @returns {void}\n   */\n  destroy() {\n    this.close();\n  }\n}\n"],
+  "mappings": "+EAWA,MAAOA,UAAgC,gBAAiB,CAXxD,MAWwD,CAAAC,EAAA,kBAQtD,YAAYC,EAAa,CACvB,MAAMA,CAAW,CACnB,CASA,KAAKC,EAAM,CACT,KAAK,YAAYA,CAAI,CACvB,CASA,UAAUC,EAAU,CAClB,KAAK,UAAaC,GAAU,CAC1BD,EAASC,EAAM,IAAI,CACrB,CACF,CAQA,SAAU,CACR,KAAK,MAAM,CACb,CACF",
+  "names": ["Broadcast", "__name", "channelName", "data", "callback", "event"]
+}

package/dist/src/classes/events/event.js

@@ -0,0 +1,2 @@
+var l=Object.defineProperty;var i=(h,t)=>l(h,"name",{value:t,configurable:!0});import{warnings as u}from"../../enums/index.js";import c from"./broadcast.js";class o extends EventTarget{static{i(this,"Event")}constructor(){super(),this.events={},this._listener_map=new Map}registerEvents(t){for(const e of Object.values(t))this.events[e]=new o}emit(t,e,s=!1,n=!0){const a=JSON.parse(JSON.stringify(e)),d=new CustomEvent(t,{detail:a,bubbles:s,cancelable:n}),p=this.dispatchEvent(d);try{const r=new c(t);r.send(a),r.destroy()}catch(r){console.warn(u.BROADCAST_FAILED,r)}return p}onBroadcast(t,e){const s=new c(t);return s.onReceive(e),s}onAny(t,e){this.on(t,e);const s=this.onBroadcast(t,e);return{event:this,broadcast:s}}on(t,e){const s=i(n=>{e(n.detail)},"wrapped_listener");return this._listener_map.set(e,s),this.addEventListener(t,s),this}once(t,e){const s=i(n=>{e(n.detail)},"wrapped_listener");return this.addEventListener(t,s,{once:!0}),this}off(t,e){if(this._listener_map&&this._listener_map.has(e)){const s=this._listener_map.get(e);this.removeEventListener(t,s),this._listener_map.delete(e)}return this}removeListener(t,e){return this.off(t,e)}}var w=o;export{w as default};
+//# sourceMappingURL=event.js.map

package/dist/src/classes/events/event.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/classes/events/event.js"],
+  "sourcesContent": ["import { errors, warnings } from '../../enums/index.js';\nimport Broadcast from './broadcast.js';\n\n/**\n * Event class for micro-flow\n * Provides a simple event emitter implementation for workflow steps and state changes.\n *\n * This class is used for emitting and listening to events within workflows and steps.\n * For broadcasting events across multiple workflows or listeners, see the Broadcast class.\n */\nclass Event extends EventTarget {\n  /**\n   * Creates a new Event instance.\n   * @constructor\n   */\n  constructor() {\n    super();\n    this.events = {};\n    this._listener_map = new Map();\n  }\n\n  /**\n   * Registers multiple events by creating Event instances for each event name.\n   * @param {Object} event_names - An object containing event name constants.\n   * @returns {void}\n   */\n  registerEvents(event_names) {\n    for (const event_name of Object.values(event_names)) {\n      this.events[event_name] = new Event();\n    }\n  }\n\n  /**\n   * Emits a custom event with optional data payload.\n   * This method maintains API compatibility with EventEmitter while using CustomEvent.\n   * @param {string} event_name - The name of the event to emit.\n   * @param {*} [data] - Optional data to pass with the event in the detail property.\n   * @param {boolean} [bubbles=false] - Whether the event should bubble up through the DOM.\n   * @param {boolean} [cancelable=true] - Whether the event is cancelable.\n   * @returns {boolean} True if the event was not cancelled, false if it was cancelled.\n   */\n  emit(event_name, data, bubbles = false, cancelable = true) {\n    const workingData = JSON.parse(JSON.stringify(data));\n\n    const custom_event = new CustomEvent(event_name, {\n      detail: workingData,\n      bubbles,\n      cancelable\n    });\n    const result = this.dispatchEvent(custom_event);\n\n    try {\n      const channel = new Broadcast(event_name);\n      channel.send(workingData);\n      channel.destroy();\n    } catch (e) {\n      console.warn(warnings.BROADCAST_FAILED, e);\n    }\n    return result;\n  }\n\n  /**\n   * Listen for broadcasts on a given event name (channel).\n   * @param {string} event_name - The event name/channel to listen for.\n   * @param {Function} listener - Callback for broadcasted data.\n   * @returns {Broadcast} Returns the Broadcast instance for manual control.\n   */\n  onBroadcast(event_name, listener) {\n    const channel = new Broadcast(event_name);\n    channel.onReceive(listener);\n    return channel;\n  }\n\n  /**\n   * Listen for both local and broadcast events.\n   * @param {string} event_name - The event name/channel to listen for.\n   * @param {Function} listener - Callback for event data.\n   * @returns {Object} Returns { event: this, broadcast: Broadcast instance }\n   */\n  onAny(event_name, listener) {\n    this.on(event_name, listener);\n    const broadcast = this.onBroadcast(event_name, listener);\n    return { event: this, broadcast };\n  }\n\n  /**\n   * Adds an event listener with EventEmitter-style API.\n   * Maintains compatibility with the original API while using addEventListener.\n   * @param {string} event_name - The name of the event to listen for.\n   * @param {Function} listener - The callback function to execute when the event fires.\n   * @returns {Event} Returns this for chaining.\n   */\n  on(event_name, listener) {\n    const wrapped_listener = (event) => {\n      // Call the listener with the detail (data) from CustomEvent\n      listener(event.detail);\n    };\n    // Store the original listener reference for removeListener\n    this._listener_map.set(listener, wrapped_listener);\n    this.addEventListener(event_name, wrapped_listener);\n    return this;\n  }\n\n  /**\n   * Adds a one-time event listener with EventEmitter-style API.\n   * @param {string} event_name - The name of the event to listen for.\n   * @param {Function} listener - The callback function to execute when the event fires.\n   * @returns {Event} Returns this for chaining.\n   */\n  once(event_name, listener) {\n    const wrapped_listener = (event) => {\n      listener(event.detail);\n    };\n    this.addEventListener(event_name, wrapped_listener, { once: true });\n    return this;\n  }\n\n  /**\n   * Removes an event listener with EventEmitter-style API.\n   * @param {string} event_name - The name of the event.\n   * @param {Function} listener - The callback function to remove.\n   * @returns {Event} Returns this for chaining.\n   */\n  off(event_name, listener) {\n    if (this._listener_map && this._listener_map.has(listener)) {\n      const wrapped_listener = this._listener_map.get(listener);\n      this.removeEventListener(event_name, wrapped_listener);\n      this._listener_map.delete(listener);\n    }\n    return this;\n  }\n\n  /**\n   * Alias for off() to maintain EventEmitter API compatibility.\n   * @param {string} event_name - The name of the event.\n   * @param {Function} listener - The callback function to remove.\n   * @returns {Event} Returns this for chaining.\n   */\n  removeListener(event_name, listener) {\n    return this.off(event_name, listener);\n  }\n}\n\nexport default Event;\n"],
+  "mappings": "+EAAA,OAAiB,YAAAA,MAAgB,uBACjC,OAAOC,MAAe,iBAStB,MAAMC,UAAc,WAAY,CAVhC,MAUgC,CAAAC,EAAA,cAK9B,aAAc,CACZ,MAAM,EACN,KAAK,OAAS,CAAC,EACf,KAAK,cAAgB,IAAI,GAC3B,CAOA,eAAeC,EAAa,CAC1B,UAAWC,KAAc,OAAO,OAAOD,CAAW,EAChD,KAAK,OAAOC,CAAU,EAAI,IAAIH,CAElC,CAWA,KAAKG,EAAYC,EAAMC,EAAU,GAAOC,EAAa,GAAM,CACzD,MAAMC,EAAc,KAAK,MAAM,KAAK,UAAUH,CAAI,CAAC,EAE7CI,EAAe,IAAI,YAAYL,EAAY,CAC/C,OAAQI,EACR,QAAAF,EACA,WAAAC,CACF,CAAC,EACKG,EAAS,KAAK,cAAcD,CAAY,EAE9C,GAAI,CACF,MAAME,EAAU,IAAIX,EAAUI,CAAU,EACxCO,EAAQ,KAAKH,CAAW,EACxBG,EAAQ,QAAQ,CAClB,OAASC,EAAG,CACV,QAAQ,KAAKb,EAAS,iBAAkBa,CAAC,CAC3C,CACA,OAAOF,CACT,CAQA,YAAYN,EAAYS,EAAU,CAChC,MAAMF,EAAU,IAAIX,EAAUI,CAAU,EACxC,OAAAO,EAAQ,UAAUE,CAAQ,EACnBF,CACT,CAQA,MAAMP,EAAYS,EAAU,CAC1B,KAAK,GAAGT,EAAYS,CAAQ,EAC5B,MAAMC,EAAY,KAAK,YAAYV,EAAYS,CAAQ,EACvD,MAAO,CAAE,MAAO,KAAM,UAAAC,CAAU,CAClC,CASA,GAAGV,EAAYS,EAAU,CACvB,MAAME,EAAmBb,EAACc,GAAU,CAElCH,EAASG,EAAM,MAAM,CACvB,EAHyB,oBAKzB,YAAK,cAAc,IAAIH,EAAUE,CAAgB,EACjD,KAAK,iBAAiBX,EAAYW,CAAgB,EAC3C,IACT,CAQA,KAAKX,EAAYS,EAAU,CACzB,MAAME,EAAmBb,EAACc,GAAU,CAClCH,EAASG,EAAM,MAAM,CACvB,EAFyB,oBAGzB,YAAK,iBAAiBZ,EAAYW,EAAkB,CAAE,KAAM,EAAK,CAAC,EAC3D,IACT,CAQA,IAAIX,EAAYS,EAAU,CACxB,GAAI,KAAK,eAAiB,KAAK,cAAc,IAAIA,CAAQ,EAAG,CAC1D,MAAME,EAAmB,KAAK,cAAc,IAAIF,CAAQ,EACxD,KAAK,oBAAoBT,EAAYW,CAAgB,EACrD,KAAK,cAAc,OAAOF,CAAQ,CACpC,CACA,OAAO,IACT,CAQA,eAAeT,EAAYS,EAAU,CACnC,OAAO,KAAK,IAAIT,EAAYS,CAAQ,CACtC,CACF,CAEA,IAAOI,EAAQhB",
+  "names": ["warnings", "Broadcast", "Event", "__name", "event_names", "event_name", "data", "bubbles", "cancelable", "workingData", "custom_event", "result", "channel", "e", "listener", "broadcast", "wrapped_listener", "event", "event_default"]
+}

package/dist/src/classes/events/index.js

@@ -0,0 +1,2 @@
+import{default as a}from"./broadcast.js";import{default as r}from"./event.js";import{default as d}from"./state_event.js";import{default as p}from"./step_event.js";import{default as m}from"./workflow_event.js";export{a as Broadcast,r as Event,d as StateEvent,p as StepEvent,m as WorkflowEvent};
+//# sourceMappingURL=index.js.map

package/dist/src/classes/events/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/classes/events/index.js"],
+  "sourcesContent": ["export { default as Broadcast } from './broadcast.js';\nexport { default as Event } from './event.js';\nexport { default as StateEvent } from './state_event.js';\nexport { default as StepEvent } from './step_event.js';\nexport { default as WorkflowEvent } from './workflow_event.js';\n"],
+  "mappings": "AAAA,OAAoB,WAAXA,MAA4B,iBACrC,OAAoB,WAAXA,MAAwB,aACjC,OAAoB,WAAXA,MAA6B,mBACtC,OAAoB,WAAXA,MAA4B,kBACrC,OAAoB,WAAXA,MAAgC",
+  "names": ["default"]
+}

package/dist/src/classes/events/state_event.js

@@ -0,0 +1,2 @@
+var r=Object.defineProperty;var t=(e,s)=>r(e,"name",{value:s,configurable:!0});import{Event as n}from"./index.js";import{state_event_names as a}from"../../enums/index.js";class i extends n{static{t(this,"StateEvent")}event_names=a;constructor(){super(),this.registerStateEvents()}registerStateEvents(){this.registerEvents(this.event_names)}}export{i as default};
+//# sourceMappingURL=state_event.js.map

package/dist/src/classes/events/state_event.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/classes/events/state_event.js"],
+  "sourcesContent": ["import { Event } from './index.js';\nimport { state_event_names } from '../../enums/index.js';\n\n/**\n * Manages state-specific events by extending the base Event class.\n * @class StateEvent\n * @extends Event\n */\nexport default class StateEvent extends Event {\n  event_names = state_event_names;\n\n  /**\n   * Creates a new StateEvent instance and registers all state events.\n   * @constructor\n   */\n  constructor() {\n    super();\n    this.registerStateEvents();\n  }\n\n  /**\n   * Registers all state event names defined in the state_event_names enum.\n   * @returns {void}\n   */\n  registerStateEvents() {\n    this.registerEvents(this.event_names);\n  }\n}\n"],
+  "mappings": "+EAAA,OAAS,SAAAA,MAAa,aACtB,OAAS,qBAAAC,MAAyB,uBAOlC,MAAOC,UAAiCF,CAAM,CAR9C,MAQ8C,CAAAG,EAAA,mBAC5C,YAAcF,EAMd,aAAc,CACZ,MAAM,EACN,KAAK,oBAAoB,CAC3B,CAMA,qBAAsB,CACpB,KAAK,eAAe,KAAK,WAAW,CACtC,CACF",
+  "names": ["Event", "state_event_names", "StateEvent", "__name"]
+}

package/dist/src/classes/events/step_event.js

@@ -0,0 +1,2 @@
+var r=Object.defineProperty;var t=(e,s)=>r(e,"name",{value:s,configurable:!0});import{Event as n}from"./index.js";import{step_event_names as i}from"../../enums/index.js";class p extends n{static{t(this,"StepEvent")}event_names=i;constructor(){super(),this.registerStepEvents()}registerStepEvents(){this.registerEvents(this.event_names)}}export{p as default};
+//# sourceMappingURL=step_event.js.map

package/dist/src/classes/events/step_event.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/classes/events/step_event.js"],
+  "sourcesContent": ["import { Event } from './index.js';\nimport { step_event_names } from '../../enums/index.js';\n\n/**\n * Manages step-specific events by extending the base Event class.\n * @class StepEvent\n * @extends Event\n */\nexport default class StepEvent extends Event {\n  event_names = step_event_names;\n\n  /**\n   * Creates a new StepEvent instance and registers all step events.\n   * @constructor\n   */\n  constructor() {\n    super();\n    this.registerStepEvents();\n  }\n  \n  /**\n   * Registers all step event names defined in the step_event_names enum.\n   * @returns {void}\n   */\n  registerStepEvents() {\n    this.registerEvents(this.event_names);\n  }\n}\n"],
+  "mappings": "+EAAA,OAAS,SAAAA,MAAa,aACtB,OAAS,oBAAAC,MAAwB,uBAOjC,MAAOC,UAAgCF,CAAM,CAR7C,MAQ6C,CAAAG,EAAA,kBAC3C,YAAcF,EAMd,aAAc,CACZ,MAAM,EACN,KAAK,mBAAmB,CAC1B,CAMA,oBAAqB,CACnB,KAAK,eAAe,KAAK,WAAW,CACtC,CACF",
+  "names": ["Event", "step_event_names", "StepEvent", "__name"]
+}

package/dist/src/classes/events/workflow_event.js

@@ -0,0 +1,2 @@
+var s=Object.defineProperty;var t=(e,r)=>s(e,"name",{value:r,configurable:!0});import{Event as o}from"./index.js";import{workflow_event_names as n}from"../../enums/index.js";class i extends o{static{t(this,"WorkflowEvent")}event_names=n;constructor(){super(),this.registerWorkflowEvents()}registerWorkflowEvents(){this.registerEvents(this.event_names)}}export{i as default};
+//# sourceMappingURL=workflow_event.js.map