react-runtime-pipe 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Delpi.Kye
+
+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,624 @@
+# ⚡ react-runtime-pipe
+
+[![NPM](https://img.shields.io/npm/v/react-runtime-pipe.svg)](https://www.npmjs.com/package/react-runtime-pipe) ![Downloads](https://img.shields.io/npm/dt/react-runtime-pipe.svg) ![Bundle Size](https://img.shields.io/bundlephobia/minzip/react-runtime-pipe)
+
+[LIVE EXAMPLE](https://codesandbox.io/p/sandbox/ps2sp8)
+
+🚀 A backend-inspired execution runtime for React applications.
+
+> Build scalable frontend systems using middleware pipelines, typed actions, dependency injection, runtime context, plugins, orchestration, and event-driven execution.
+
+---
+
+# Installation
+
+```bash
+npm install react-runtime-pipe
+```
+
+# What is react-runtime-pipe?
+
+`react-runtime-pipe` is a lightweight runtime for executing backend-style logic in React applications.
+
+It brings concepts like middleware, dependency injection, and orchestration into frontend code.
+
+It provides:
+
+- typed action execution  
+- middleware pipelines  
+- dependency injection  
+- runtime context  
+- plugins and event system  
+- retry and cancellation support  
+
+without enforcing any specific state management approach.
+
+---
+
+# Why react-runtime-pipe?
+
+Frontend apps often become hard to scale as logic spreads across components and async flows become inconsistent.
+
+Common problems:
+
+- business logic inside UI components  
+- duplicated async logic  
+- scattered dependencies  
+- tightly coupled side effects  
+- inconsistent orchestration  
+
+react-runtime-pipe solves this by introducing a structured execution layer:
+
+- predictable execution flow  
+- composable middleware  
+- centralized orchestration  
+- backend-like architecture in frontend  
+- framework-agnostic design  
+
+---
+
+# Features
+
+- ⚡ Runtime-first architecture
+- 🧩 Middleware pipeline
+- 🔌 Plugin system
+- 🧠 Typed execution context
+- 🛡 Action lifecycle hooks
+- ♻️ Retry orchestration
+- 📦 Dependency injection container
+- 📡 Event bus system
+- 📝 Full TypeScript inference
+- 🚦 Abort/cancellation support
+- 💾 Scoped execution cache
+- ⚛️ React integration
+- 🧱 Framework agnostic core
+
+---
+
+# Mental Model
+
+```text
+UI Event
+    ↓
+useAction()
+    ↓
+createExecutionContext()
+    ↓
+Plugins
+    ↓
+Middleware Pipeline
+    ↓
+Action Handler
+    ↓
+Service Layer
+    ↓
+Event Bus
+    ↓
+UI Update
+```
+
+---
+
+# Quick Start
+
+## Create App
+
+```ts
+// app.ts
+import { createApp } from 'react-runtime-pipe'
+import { loggerPlugin } from 'react-runtime-pipe/plugin'
+
+import { ApiService } from './services/api'
+import { ApiServiceToken } from './tokens'
+
+export const app = createApp({
+  services: [
+    {
+      token: ApiServiceToken,
+      useValue: new ApiService(),
+    },
+  ],
+})
+
+app.plugin(loggerPlugin)
+
+```
+
+---
+
+## Define Action
+
+```ts
+import { defineAction } from 'react-runtime-pipe'
+import { globalEvents } from 'react-runtime-pipe/react'
+import { logger, retry } from 'react-runtime-pipe/middleware'
+
+import { ApiServiceToken } from './tokens'
+
+export const saveUserAction = defineAction({
+  name: 'save-user',
+
+  middleware: [logger, retry(3)],
+
+  async handler({ input, context }) {
+    context.logger.info('saving user', input)
+
+    const api = context.container.resolve(ApiServiceToken)
+
+    const user = await api.saveUser(input)
+
+    // context.events.$emit('user:saved', user)
+    globalEvents.$emit('user:saved', user)
+
+    return {
+      success: true,
+      user,
+    }
+  },
+})
+```
+
+---
+
+## Service Implementation
+
+```ts
+// api.ts
+import { createRequestId } from 'react-runtime-pipe'
+
+export class ApiService {
+  async saveUser(input: any) {
+    await new Promise((resolve) => {
+      setTimeout(resolve, 500)
+    })
+
+    return {
+      id: createRequestId(),
+      input,
+    }
+  }
+}
+```
+
+---
+
+## Tokens
+
+```ts
+// tokens.ts
+import { createToken } from 'react-runtime-pipe'
+
+import type { ApiService } from './services/api'
+
+export const ApiServiceToken =
+  createToken<ApiService>('ApiService')
+```
+
+---
+
+## React Usage
+
+```tsx
+// Root.tsx
+import React from 'react'
+
+import {
+  useAction,
+  useEventBus,
+  globalEvents,
+} from 'react-runtime-pipe/react'
+
+import { saveUserAction } from './saveUser'
+
+export function Root() {
+  const saveUser = useAction(saveUserAction)
+
+  useEventBus(
+    'user:saved',
+    () => {
+      alert('User saved successfully!')
+    },
+    globalEvents,
+  )
+
+  return (
+    <div>
+      <button
+        disabled={saveUser.loading}
+        onClick={() => {
+          saveUser.execute({
+            name: 'Tung',
+          })
+        }}
+      >
+        {saveUser.loading
+          ? 'Saving...'
+          : 'Save User'}
+      </button>
+
+      {saveUser.error ? (
+        <pre>{String(saveUser.error)}</pre>
+      ) : null}
+    </div>
+  )
+}
+```
+
+---
+
+## Bootstrap
+
+```tsx
+// main.tsx
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+
+import { RuntimeProvider } from 'react-runtime-pipe/react'
+
+import { Root } from './Root'
+import { app } from './app'
+
+async function bootstrap() {
+  await app.run()
+
+  const rootElement =
+    document.getElementById('root')
+
+  if (!rootElement) {
+    throw new Error(
+      'Root element #root not found',
+    )
+  }
+
+  ReactDOM.createRoot(rootElement).render(
+    <React.StrictMode>
+      <RuntimeProvider app={app}>
+        <App />
+      </RuntimeProvider>
+    </React.StrictMode>,
+  )
+}
+
+bootstrap()
+```
+
+---
+
+# Dependency Injection
+
+```ts
+import { createApp, createToken } from 'react-runtime-pipe'
+
+class ApiService {
+  async saveUser() {}
+}
+
+const ApiServiceToken = createToken<ApiService>('ApiService')
+
+const app = createApp({
+  services: [
+    {
+      token: ApiServiceToken,
+      useFactory: () =>
+        new ApiService(),
+    },
+  ],
+})
+```
+
+---
+
+## Service Injection in Actions
+
+```ts
+import { defineAction } from 'react-runtime-pipe'
+
+import { ApiServiceToken } from './tokens'
+
+export const saveUserAction =
+  defineAction({
+    name: 'save-user',
+
+    async handler({
+      input,
+      context,
+    }) {
+      const api =
+        context.container.resolve(
+          ApiServiceToken,
+        )
+
+      return api.saveUser(input)
+    },
+  })
+```
+
+---
+
+## useService hook
+
+```tsx
+import { useService } from 'react-runtime-pipe/react'
+
+import { ApiServiceToken } from './tokens'
+
+export function UserPage() {
+  const api = useService(ApiServiceToken)
+
+  return null
+}
+```
+
+---
+
+# Runtime Context
+
+| Property      | Description              |
+|---------------|--------------------------|
+| ctx.requestId | execution request id     |
+| ctx.signal    | abort signal             |
+| ctx.logger    | runtime logger           |
+| ctx.container | dependency container     |
+| ctx.events    | execution event bus      |
+| ctx.cache     | scoped execution cache   |
+| ctx.auth      | authenticated user state |
+
+---
+
+# Event Bus
+
+## Emit Event
+
+```ts
+globalEvents.$emit(
+  'user:saved',
+  user,
+)
+```
+
+---
+
+## Listen To Event
+
+```ts
+useEventBus(
+  'user:saved',
+  (payload) => {
+    console.log(payload)
+  },
+  globalEvents,
+)
+```
+
+---
+
+# Middleware
+
+Middleware in `react-runtime-pipe` allows you to intercept and control the execution flow of an action.
+
+Here is a simple example: **Abort Middleware** — used to stop execution if the request has been cancelled.
+
+```ts
+import type { Middleware } from 'react-runtime-pipe'
+
+export const abortMiddleware: Middleware = async ({
+  context,
+  next,
+}) => {
+  // check before executing the handler
+  context.throwIfAborted()
+
+  const result = await next()
+
+  // check after the handler finishes
+  context.throwIfAborted()
+
+  return result
+}
+```
+
+This middleware ensures that if the user triggers an abort (e.g. cancels a request or unmounts a component), the action is immediately stopped both before and after execution.
+
+---
+
+# Plugins
+
+```ts
+import type { Plugin } from 'react-runtime-pipe'
+
+const analyticsPlugin: Plugin = {
+  name: 'analytics',
+
+  setup({ app }) {
+    console.log('plugin setup')
+  },
+}
+
+app.plugin(analyticsPlugin)
+```
+
+---
+
+# React Runtime Provider
+
+```tsx
+import { RuntimeProvider } from 'react-runtime-pipe/react'
+
+import { app } from './app'
+
+export function Root() {
+  return (
+    <RuntimeProvider app={app}>
+      <App />
+    </RuntimeProvider>
+  )
+}
+```
+
+---
+
+# Action Lifecycle
+
+```text
+useAction.execute()
+      ↓
+createExecutionContext()
+      ↓
+composeMiddleware()
+      ↓
+executeHandler()
+      ↓
+emitEvents()
+      ↓
+returnResult()
+```
+
+---
+
+# Execution Cache
+
+```ts
+const cacheKey = 'user:1'
+
+if (ctx.cache.has(cacheKey)) {
+  return ctx.cache.get(cacheKey)
+}
+
+const user = await api.getUser()
+
+ctx.cache.set(cacheKey, user)
+
+return user
+```
+
+---
+
+# Abort Support
+
+```ts
+ctx.throwIfAborted()
+```
+
+```ts
+ctx.signal.addEventListener(
+  'abort',
+  () => {
+    console.log('cancelled')
+  },
+)
+```
+
+---
+
+# Full Example
+
+```ts
+import { defineAction } from 'react-runtime-pipe'
+
+import {
+  logger,
+  retry,
+  auth,
+} from 'react-runtime-pipe/middleware'
+
+import { ApiServiceToken } from './tokens'
+
+import { globalEvents } from './events'
+
+export const saveUserAction =
+  defineAction({
+    name: 'save-user',
+
+    middleware: [
+      auth,
+      logger,
+      retry(),
+    ],
+
+    async handler({
+      input,
+      context,
+    }) {
+      const api =
+        context.container.resolve(
+          ApiServiceToken,
+        )
+
+      const user =
+        await api.saveUser(input)
+
+      globalEvents.$emit(
+        'user:saved',
+        user,
+      )
+
+      return {
+        success: true,
+        user,
+      }
+    },
+  })
+```
+
+---
+
+# Comparison
+
+| Createria            | Redux  | React Query  | react-runtime-pipe |
+| -------------------- | ------ | ------------ | ------------------ |
+| Middleware Pipeline  | ✅     | ❌           | ✅                  |
+| Dependency Injection | ❌     | ❌           | ✅                  |
+| Runtime Context      | ❌     | ❌           | ✅                  |
+| Event Bus            | ❌     | ❌           | ✅                  |
+| Orchestration Layer  | ❌     | ⚠️           | ✅                  |
+| Service Execution    | ❌     | ⚠️           | ✅                  |
+| Plugin System        | ❌     | ❌           | ✅                  |
+
+---
+
+# Philosophy
+
+```text
+You control:
+- middleware
+- plugins
+- orchestration
+- architecture
+- services
+
+react-runtime-pipe controls:
+- execution
+- lifecycle
+- context
+- typing
+- pipelines
+```
+
+---
+
+# Design
+
+- Explicit execution
+- Composition over inheritance
+- Backend-inspired architecture
+- Runtime-first design
+- Framework-agnostic core
+- Deterministic orchestration
+
+---
+
+# When to Use
+
+- Large React applications
+- Complex async flows
+- Plugin-based frontends
+- Runtime orchestration systems
+- Event-driven UI architecture
+- Shared business execution layers
+- Backend/frontend unified patterns
+
+---
+
+# License
+
+MIT

package/build/action/compose.d.ts

@@ -0,0 +1,7 @@
+import type { Middleware, RuntimeContext } from './types';
+export declare function composeMiddleware<TInput, TResult>(params: {
+    middleware: Middleware<TInput, TResult>[];
+    execute(): Promise<TResult>;
+    input: TInput;
+    context: RuntimeContext;
+}): Promise<TResult>;

package/build/action/defineAction.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAction } from './types';
+export declare function defineAction<TInput, TResult>(action: RuntimeAction<TInput, TResult>): RuntimeAction<TInput, TResult>;

package/build/action/executeAction.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeAction, RuntimeContext } from './types';
+export declare function executeAction<TInput, TResult>(params: {
+    action: RuntimeAction<TInput, TResult>;
+    input: TInput;
+    context: RuntimeContext;
+}): Promise<TResult>;

package/build/action/index.d.ts

@@ -0,0 +1,4 @@
+export * from './defineAction';
+export * from './executeAction';
+export * from './types';
+export * from './utils';

package/build/action/types.d.ts

@@ -0,0 +1,48 @@
+import { createEventBus } from 'eventbus-z';
+import type { RuntimeContainer } from '../app/container';
+export type RuntimeLogger = {
+    info(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+};
+export type RuntimeEventBus = ReturnType<typeof createEventBus>;
+export type GlobalEventBus = ReturnType<typeof createEventBus>;
+export type TypedRuntimeEventBus<TEvents extends Record<string, any[]>> = {
+    $emit<K extends keyof TEvents>(event: K, ...args: TEvents[K]): void;
+    $on<K extends keyof TEvents>(event: K, listener: (...args: TEvents[K]) => void): () => void;
+    $off?<K extends keyof TEvents>(event: K, listener?: (...args: TEvents[K]) => void): void;
+    $once?<K extends keyof TEvents>(event: K, listener: (...args: TEvents[K]) => void): void;
+};
+export type RuntimeContext = {
+    requestId: string;
+    signal: AbortSignal;
+    container: RuntimeContainer;
+    logger: RuntimeLogger;
+    events: RuntimeEventBus;
+    globalEvents?: GlobalEventBus;
+    cache: Map<string, unknown>;
+    auth?: {
+        userId: string;
+    };
+    throwIfAborted(): void;
+};
+export type ActionNext<TResult> = () => Promise<TResult>;
+export type Middleware<TInput = unknown, TResult = unknown> = (params: {
+    input: TInput;
+    context: RuntimeContext;
+    next: ActionNext<TResult>;
+}) => Promise<TResult>;
+export type ActionHandler<TInput, TResult> = (params: {
+    input: TInput;
+    context: RuntimeContext;
+}) => Promise<TResult>;
+export type RuntimeAction<TInput, TResult> = {
+    name: string;
+    middleware?: Middleware<TInput, TResult>[];
+    retry?: {
+        attempts: number;
+    };
+    handler: ActionHandler<TInput, TResult>;
+};
+export type RuntimeSystem = {
+    globalEvents: GlobalEventBus;
+};

package/build/action/utils.d.ts

@@ -0,0 +1 @@
+export declare function createRequestId(): string;

package/build/app/container.d.ts

@@ -0,0 +1,17 @@
+export type Token<T = any> = symbol & {
+    __type?: T;
+};
+export declare function createToken<T>(description: string): Token<T>;
+type Scope = 'singleton' | 'scoped';
+type Provider<T> = {
+    scope?: Scope;
+    useValue?: T;
+    useFactory?: () => T;
+};
+export type RuntimeContainer = ReturnType<typeof createContainer>;
+export declare function createContainer(): {
+    register<T>(token: Token<T>, provider: Provider<T>): void;
+    resolve<T>(token: Token<T>): T;
+    has<T>(token: Token<T>): boolean;
+};
+export {};

package/build/app/createApp.d.ts

@@ -0,0 +1,21 @@
+import { createContainer, type Token } from './container';
+import type { Middleware, RuntimeContext } from '../action/types';
+import type { Plugin } from './plugin';
+export type ServiceProvider<T = any> = {
+    token: Token<T>;
+    useValue: T;
+};
+export type CreateAppOptions = {
+    services?: ServiceProvider[];
+};
+export type RuntimeApp = {
+    container: ReturnType<typeof createContainer>;
+    readonly plugins: Plugin[];
+    readonly middlewares: Middleware[];
+    initialized: boolean;
+    createContext(): Promise<Partial<RuntimeContext>>;
+    plugin(plugin: Plugin): RuntimeApp;
+    use(middleware: Middleware): RuntimeApp;
+    run(): Promise<void>;
+};
+export declare function createApp(options?: CreateAppOptions): RuntimeApp;

package/build/app/index.d.ts

@@ -0,0 +1,3 @@
+export * from './container';
+export * from './createApp';
+export * from './plugin';

package/build/app/plugin.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeContext } from '../action/types';
+import type { RuntimeApp } from './createApp';
+export type PluginContext = {
+    app: RuntimeApp;
+};
+export type Plugin = {
+    name: string;
+    setup?(context: PluginContext): void;
+    createContext?(): Promise<Partial<RuntimeContext>>;
+};

package/build/cjs/index.js

@@ -0,0 +1 @@
+"use strict";function e(){const e=new Map,t=new Map;return{register(n,r){t.set(n,r),r.useValue&&e.set(n,r.useValue)},resolve(n){if(e.has(n))return e.get(n);const r=t.get(n);if(!r)throw Error("Missing dependency: "+(n+""));if(r.useFactory){const t=r.useFactory();return"scoped"!==r.scope&&e.set(n,t),t}return r.useValue},has:e=>t.has(e)}}async function t(e){const{middleware:t,execute:n,input:r,context:o}=e;return async function e(c){const s=t[c];if(!s)return n();let i=!1;return s({input:r,context:o,next:async()=>{if(i)throw Error("next() already called");return i=!0,e(c+1)}})}(0)}exports.createApp=function(t={}){const n=e(),r=[],o=[];for(const e of t.services??[])n.register(e.token,{useValue:e.useValue});const c={container:n,plugins:r,middlewares:o,initialized:!1,async createContext(){let e={};for(const t of r){if(!t.createContext)continue;const n=await t.createContext();e={...e,...n}}return e},plugin:e=>(r.push(e),c),use:e=>(o.push(e),c),async run(){if(!c.initialized){c.initialized=!0;for(const e of r)await(e.setup?.({app:c}))}}};return c},exports.createContainer=e,exports.createRequestId=function(){return Array.from({length:16},()=>Math.floor(16*Math.random()).toString(16)).join("")},exports.createToken=function(e){return Symbol(e)},exports.defineAction=function(e){return e},exports.executeAction=async function(e){const{action:n,input:r,context:o}=e,c=n.retry?.attempts??1;let s;for(let e=0;e<c;e++)try{return await t({middleware:n.middleware??[],input:r,context:o,execute:async()=>(o.throwIfAborted(),n.handler({input:r,context:o}))})}catch(e){s=e}throw s};

package/build/cjs/middleware/index.js

@@ -0,0 +1 @@
+"use strict";function e(){return"undefined"!=typeof performance?performance.now():Date.now()}exports.abortMiddleware=async({context:e,next:t})=>{e.throwIfAborted();const r=await t();return e.throwIfAborted(),r},exports.auth=function(){return async({context:e,next:t})=>{if(!e.auth?.userId)throw Error("Unauthorized");return t()}},exports.cacheMiddleware=async({context:e,next:t})=>{const r=e.requestId,o=e.cache.get(r);if(o)return e.logger.info("[cache:hit]",{key:r}),o;const n=await t();return e.cache.set(r,n),e.logger.info("[cache:set]",{key:r}),n},exports.eventMiddleware=async({context:e,next:t})=>{e.events?.$emit("action:start",{requestId:e.requestId});try{const r=await t();return e.events?.$emit("action:success",{requestId:e.requestId}),r}catch(t){throw e.events?.$emit("action:error",{requestId:e.requestId,error:t}),t}},exports.logger=async({context:e,input:t,next:r})=>{const o="undefined"!=typeof performance?performance.now():Date.now();e.logger.info("[action:start]",{requestId:e.requestId,input:t});try{const t=await r(),n="undefined"!=typeof performance?performance.now():Date.now();return e.logger.info("[action:success]",{requestId:e.requestId,duration:n-o}),t}catch(t){const r="undefined"!=typeof performance?performance.now():Date.now();throw e.logger.error("[action:error]",{requestId:e.requestId,duration:r-o,error:t instanceof Error?t.message:t}),t}},exports.retry=function(e=3){return async({context:t,next:r})=>{let o;for(let n=1;n<=e;n++)try{t.logger.info("[retry:attempt]",{requestId:t.requestId,attempt:n,max:e}),t.throwIfAborted();const o=await r();return n>1&&t.logger.info("[retry:success-after-retry]",{requestId:t.requestId,attempt:n}),o}catch(e){o=e,t.logger.error("[retry:fail]",{requestId:t.requestId,attempt:n,error:e}),t.events.$emit("retry:fail",{requestId:t.requestId,attempt:n,error:e})}throw t.logger.error("[retry:exhausted]",{requestId:t.requestId,attempts:e,error:o}),o}},exports.timing=async({context:t,next:r})=>{const o=e(),n=t.requestId;t.logger.info("[timing:start]",{requestId:n});try{const s=await r(),a=e()-o;return t.logger.info("[timing:success]",{requestId:n,duration:a}),t.events.$emit("timing",{requestId:n,duration:a}),s}catch(r){const s=e()-o;throw t.logger.error("[timing:error]",{requestId:n,duration:s,error:r}),r}};

package/build/cjs/plugin/index.js

@@ -0,0 +1 @@
+"use strict";const e={name:"auth",createContext:async()=>({auth:await Promise.resolve({userId:"user_123"})})},t={name:"cache",createContext:async()=>({cache:new Map})},s="__EVENT_BUS_GLOBAL_SCOPE__",o=()=>(()=>{const e=(()=>{if("undefined"!=typeof window){try{if(window.top)return window.top.location.href,window.top}catch(e){}return window}return"undefined"!=typeof globalThis?globalThis:{}})();return e[s]||Object.defineProperty(e,s,{value:{},writable:!1,enumerable:!1,configurable:!1}),e[s]})(),c="evtBusZxp_scopeZxp",n="globalZxp_defaultName",a=(e,t=n)=>{const s=`${c}__${t}`;return e[s]||(e[s]=new Map),e[s]},i="eventBusRegister_"+c,r=(e,t,s)=>{var o;if(!t||"function"!=typeof s.callback)throw Error("Event name and callback are required");const c=null!==(o=s.scopeName)&&void 0!==o?o:n,r=a(e,c);r.has(t)||r.set(t,new Set);const l=r.get(t);s.single&&l.clear(),l.forEach(e=>{e.callback===s.callback&&l.delete(e)}),l.add(Object.assign({},s)),((e,t,s=n)=>{var o;const c=null!==(o=e[i])&&void 0!==o?o:{};c[s]||(c[s]=new Set),c[s].add(t),e[i]=c})(e,t,c)};function l(e,t){let s=-1;const o=c=>{if(c<=s)return;s=c;const i=e._middlewares[c];i?i(t,()=>o(c+1)):((e,t,s=n,...o)=>{const c=a(e,s).get(t);if(!c)return;const i=Date.now();c.forEach(e=>{e.once&&e.emitted||e.timeCached&&e.timeEffect&&i-e.timeEffect<e.timeCached||(e.callback(...o),e.emitted=!0,e.timeEffect=i)})})(e._scope,t.name,t.scopeName,...t.args)};o(0)}class h{constructor(e=o()){this._middlewares=[],this._isBatching=!1,this._queue=[],this.$use=e=>{this._middlewares.push(e)},this.$batch=e=>{this._isBatching=!0;try{e()}finally{this._isBatching=!1,function(e){const t=e._queue;for(let s=0;s<t.length;s++)l(e,t[s]);t.length=0}(this)}},this.$once=(e,t)=>{r(this._scope,e,{callback:t,once:!0})},this.$on=(e,t)=>{r(this._scope,e,{callback:t,single:!0})},this.$onMultiple=(e,t)=>{r(this._scope,e,{callback:t})},this.$onCached=(e,t,s=100)=>{r(this._scope,e,{callback:t,single:!0,timeCached:s})},this.$onCachedMultiple=(e,t,s=100)=>{r(this._scope,e,{callback:t,timeCached:s})},this.$emit=(e,...t)=>{const s={scopeName:n,name:e,args:t};this._isBatching?this._queue.push(s):l(this,s)},this.$off=(e,t)=>{const s=a(this._scope,n),o=s.get(e);o&&(t?o.forEach(e=>{e.callback===t&&o.delete(e)}):s.delete(e))},this.$offAll=e=>{a(this._scope,n).delete(e)},this.$destroy=()=>{!function(e){Object.keys(e).forEach(t=>{delete e[t]})}(this._scope)},this.$clearEventAcrossScopes=e=>{const t=(()=>{var e;return null!==(e=this._scope[i])&&void 0!==e?e:{}})();Object.keys(t).forEach(s=>{var o;(null===(o=t[s])||void 0===o?void 0:o.has(e))&&a(this._scope,s).delete(e)})},this.$scopeEmit=(e,t,...s)=>{const o={scopeName:e,name:t,args:s};this._isBatching?this._queue.push(o):l(this,o)},this.$scopeOn=(e,t,s)=>{r(this._scope,t,{callback:s,single:!0,scopeName:e})},this.$scopeOnce=(e,t,s)=>{r(this._scope,t,{callback:s,once:!0,scopeName:e})},this.$scopeOnMultiple=(e,t,s)=>{r(this._scope,t,{callback:s,scopeName:e})},this.$scopeOnCached=(e,t,s,o=100)=>{r(this._scope,t,{callback:s,single:!0,timeCached:o,scopeName:e})},this.$scopeOnCachedMultiple=(e,t,s,o=100)=>{r(this._scope,t,{callback:s,timeCached:o,scopeName:e})},this.$scopeOff=(e,t,s)=>{const o=a(this._scope,e),c=o.get(t);c&&(s?c.forEach(e=>{e.callback===s&&c.delete(e)}):o.delete(t))},this.$scopeOffAll=(e,t)=>{a(this._scope,e).delete(t)},this._scope=e}}function p(e,t){return new h(Object.create(null))}const u=p(),{$once:d,$on:f,$off:g,$offAll:m,$emit:$,$onCached:_,$onMultiple:b,$onCachedMultiple:w,$clearEventAcrossScopes:v,$destroy:y,$scopeOn:E,$scopeOnce:x,$scopeOnMultiple:O,$scopeOnCached:C,$scopeOnCachedMultiple:k,$scopeEmit:q,$scopeOff:I,$scopeOffAll:N}=u,M=p(),B={name:"event",createContext:async()=>({globalEvents:M}),setup({app:e}){e.use(async({context:e,next:t})=>{const s=e.globalEvents;s.$emit("action:start",{requestId:e.requestId});try{const o=await t();return s.$emit("action:success",{requestId:e.requestId}),o}catch(t){throw s.$emit("action:error",{requestId:e.requestId,error:t}),t}})}},P={name:"logger",createContext:async()=>({logger:{info:console.log,error:console.error}})},A={name:"logger",setup({app:e}){e.use(async({context:e,next:t})=>{const s="undefined"!=typeof performance?performance.now():Date.now(),o=e.requestId;e.logger.info("[action:start]",{requestId:o});const c=e.globalEvents;c?.$emit?.("action:start",{requestId:o});try{const n=await t(),a="undefined"!=typeof performance?performance.now():Date.now();return e.logger.info("[action:success]",{requestId:o,duration:a-s}),c?.$emit?.("action:success",{requestId:o,duration:a-s}),n}catch(t){const n="undefined"!=typeof performance?performance.now():Date.now();throw e.logger.error("[action:error]",{requestId:o,duration:n-s,error:t}),c?.$emit?.("action:error",{requestId:o,error:t}),t}})},createContext:async()=>({logger:{info:console.log,error:console.error},globalEvents:p()})};exports.authPlugin=e,exports.cachePlugin=t,exports.devtoolsPlugin=e=>({name:"devtools",setup({app:t}){e.enabled&&t.use(async({context:e,next:t})=>await t())}}),exports.eventPlugin=B,exports.globalEvents=M,exports.loggerAdvancePlugin=A,exports.loggerPlugin=P;

package/build/cjs/react/index.js

@@ -0,0 +1 @@
+"use strict";var e=require("react/jsx-runtime"),t=require("react");const c=t.createContext(null);function n(){const e=t.useContext(c);if(!e)throw Error("Missing RuntimeProvider");return e}const o="__EVENT_BUS_GLOBAL_SCOPE__",s=()=>(()=>{const e=(()=>{if("undefined"!=typeof window){try{if(window.top)return window.top.location.href,window.top}catch(e){}return window}return"undefined"!=typeof globalThis?globalThis:{}})();return e[o]||Object.defineProperty(e,o,{value:{},writable:!1,enumerable:!1,configurable:!1}),e[o]})(),i="evtBusZxp_scopeZxp",r="globalZxp_defaultName",a=(e,t=r)=>{const c=`${i}__${t}`;return e[c]||(e[c]=new Map),e[c]},l="eventBusRegister_"+i,u=(e,t,c)=>{var n;if(!t||"function"!=typeof c.callback)throw Error("Event name and callback are required");const o=null!==(n=c.scopeName)&&void 0!==n?n:r,s=a(e,o);s.has(t)||s.set(t,new Set);const i=s.get(t);c.single&&i.clear(),i.forEach(e=>{e.callback===c.callback&&i.delete(e)}),i.add(Object.assign({},c)),((e,t,c=r)=>{var n;const o=null!==(n=e[l])&&void 0!==n?n:{};o[c]||(o[c]=new Set),o[c].add(t),e[l]=o})(e,t,o)};function h(e,t){let c=-1;const n=o=>{if(o<=c)return;c=o;const s=e._middlewares[o];s?s(t,()=>n(o+1)):((e,t,c=r,...n)=>{const o=a(e,c).get(t);if(!o)return;const s=Date.now();o.forEach(e=>{e.once&&e.emitted||e.timeCached&&e.timeEffect&&s-e.timeEffect<e.timeCached||(e.callback(...n),e.emitted=!0,e.timeEffect=s)})})(e._scope,t.name,t.scopeName,...t.args)};n(0)}class p{constructor(e=s()){this._middlewares=[],this._isBatching=!1,this._queue=[],this.$use=e=>{this._middlewares.push(e)},this.$batch=e=>{this._isBatching=!0;try{e()}finally{this._isBatching=!1,function(e){const t=e._queue;for(let c=0;c<t.length;c++)h(e,t[c]);t.length=0}(this)}},this.$once=(e,t)=>{u(this._scope,e,{callback:t,once:!0})},this.$on=(e,t)=>{u(this._scope,e,{callback:t,single:!0})},this.$onMultiple=(e,t)=>{u(this._scope,e,{callback:t})},this.$onCached=(e,t,c=100)=>{u(this._scope,e,{callback:t,single:!0,timeCached:c})},this.$onCachedMultiple=(e,t,c=100)=>{u(this._scope,e,{callback:t,timeCached:c})},this.$emit=(e,...t)=>{const c={scopeName:r,name:e,args:t};this._isBatching?this._queue.push(c):h(this,c)},this.$off=(e,t)=>{const c=a(this._scope,r),n=c.get(e);n&&(t?n.forEach(e=>{e.callback===t&&n.delete(e)}):c.delete(e))},this.$offAll=e=>{a(this._scope,r).delete(e)},this.$destroy=()=>{!function(e){Object.keys(e).forEach(t=>{delete e[t]})}(this._scope)},this.$clearEventAcrossScopes=e=>{const t=(()=>{var e;return null!==(e=this._scope[l])&&void 0!==e?e:{}})();Object.keys(t).forEach(c=>{var n;(null===(n=t[c])||void 0===n?void 0:n.has(e))&&a(this._scope,c).delete(e)})},this.$scopeEmit=(e,t,...c)=>{const n={scopeName:e,name:t,args:c};this._isBatching?this._queue.push(n):h(this,n)},this.$scopeOn=(e,t,c)=>{u(this._scope,t,{callback:c,single:!0,scopeName:e})},this.$scopeOnce=(e,t,c)=>{u(this._scope,t,{callback:c,once:!0,scopeName:e})},this.$scopeOnMultiple=(e,t,c)=>{u(this._scope,t,{callback:c,scopeName:e})},this.$scopeOnCached=(e,t,c,n=100)=>{u(this._scope,t,{callback:c,single:!0,timeCached:n,scopeName:e})},this.$scopeOnCachedMultiple=(e,t,c,n=100)=>{u(this._scope,t,{callback:c,timeCached:n,scopeName:e})},this.$scopeOff=(e,t,c)=>{const n=a(this._scope,e),o=n.get(t);o&&(c?o.forEach(e=>{e.callback===c&&o.delete(e)}):n.delete(t))},this.$scopeOffAll=(e,t)=>{a(this._scope,e).delete(t)},this._scope=e}}function d(e,t){return new p(Object.create(null))}const f=d(),{$once:m,$on:_,$off:$,$offAll:b,$emit:g,$onCached:w,$onMultiple:v,$onCachedMultiple:x,$clearEventAcrossScopes:E,$destroy:y,$scopeOn:O,$scopeOnce:k,$scopeOnMultiple:C,$scopeOnCached:M,$scopeOnCachedMultiple:A,$scopeEmit:N,$scopeOff:B,$scopeOffAll:S}=f;async function j(e){const{middleware:t,execute:c,input:n,context:o}=e;return async function e(s){const i=t[s];if(!i)return c();let r=!1;return i({input:n,context:o,next:async()=>{if(r)throw Error("next() already called");return r=!0,e(s+1)}})}(0)}const q=d();exports.RuntimeProvider=function(t){return e.jsx(c.Provider,{value:t.app,children:t.children})},exports.globalEvents=q,exports.useAction=function(e){const c=n(),o=t.useRef(null),[s,i]=t.useState(!1),[r,a]=t.useState(null),l=t.useMemo(()=>d(),[]);return{execute:async function(t){i(!0),a(null);const n=new AbortController;o.current=n;try{const o=await(c.createContext?.()),s=await async function(e){const{action:t,input:c,context:n}=e,o=t.retry?.attempts??1;let s;for(let e=0;e<o;e++)try{return await j({middleware:t.middleware??[],input:c,context:n,execute:async()=>(n.throwIfAborted(),t.handler({input:c,context:n}))})}catch(e){s=e}throw s}({action:e,input:t,context:{requestId:Array.from({length:16},()=>Math.floor(16*Math.random()).toString(16)).join(""),signal:n.signal,container:c.container,cache:new Map,events:l,logger:{info:console.log,error:console.error},throwIfAborted(){if(n.signal.aborted)throw Error("Action aborted")},...o}});return s}catch(e){throw a(e),e}finally{i(!1),o.current=null}},abort:function(){o.current?.abort()},loading:s,error:r,events:l,globalEvents:q}},exports.useEventBus=function(e,c,n=f){const o=t.useRef(c);o.current=c,t.useEffect(()=>{const t=(...e)=>{o.current(...e)};return n.$on(e,t),()=>{n.$off(e,t)}},[e,n])},exports.useRuntime=n,exports.useService=function(e){return n().container.resolve(e)};

package/build/esm/index.js

@@ -0,0 +1 @@
+function t(t){return Symbol(t)}function e(){const t=new Map,e=new Map;return{register(n,r){e.set(n,r),r.useValue&&t.set(n,r.useValue)},resolve(n){if(t.has(n))return t.get(n);const r=e.get(n);if(!r)throw Error("Missing dependency: "+(n+""));if(r.useFactory){const e=r.useFactory();return"scoped"!==r.scope&&t.set(n,e),e}return r.useValue},has:t=>e.has(t)}}function n(t={}){const n=e(),r=[],o=[];for(const e of t.services??[])n.register(e.token,{useValue:e.useValue});const i={container:n,plugins:r,middlewares:o,initialized:!1,async createContext(){let t={};for(const e of r){if(!e.createContext)continue;const n=await e.createContext();t={...t,...n}}return t},plugin:t=>(r.push(t),i),use:t=>(o.push(t),i),async run(){if(!i.initialized){i.initialized=!0;for(const t of r)await(t.setup?.({app:i}))}}};return i}function r(t){return t}async function o(t){const{middleware:e,execute:n,input:r,context:o}=t;return async function t(i){const c=e[i];if(!c)return n();let u=!1;return c({input:r,context:o,next:async()=>{if(u)throw Error("next() already called");return u=!0,t(i+1)}})}(0)}async function i(t){const{action:e,input:n,context:r}=t,i=e.retry?.attempts??1;let c;for(let t=0;t<i;t++)try{return await o({middleware:e.middleware??[],input:n,context:r,execute:async()=>(r.throwIfAborted(),e.handler({input:n,context:r}))})}catch(t){c=t}throw c}function c(){return Array.from({length:16},()=>Math.floor(16*Math.random()).toString(16)).join("")}export{n as createApp,e as createContainer,c as createRequestId,t as createToken,r as defineAction,i as executeAction};

package/build/esm/middleware/index.js

@@ -0,0 +1 @@
+const e=async({context:e,next:t})=>{e.throwIfAborted();const r=await t();return e.throwIfAborted(),r};function t(){return async({context:e,next:t})=>{if(!e.auth?.userId)throw Error("Unauthorized");return t()}}const r=async({context:e,next:t})=>{const r=e.requestId,n=e.cache.get(r);if(n)return e.logger.info("[cache:hit]",{key:r}),n;const o=await t();return e.cache.set(r,o),e.logger.info("[cache:set]",{key:r}),o},n=async({context:e,next:t})=>{e.events?.$emit("action:start",{requestId:e.requestId});try{const r=await t();return e.events?.$emit("action:success",{requestId:e.requestId}),r}catch(t){throw e.events?.$emit("action:error",{requestId:e.requestId,error:t}),t}},o=async({context:e,input:t,next:r})=>{const n="undefined"!=typeof performance?performance.now():Date.now();e.logger.info("[action:start]",{requestId:e.requestId,input:t});try{const t=await r(),o="undefined"!=typeof performance?performance.now():Date.now();return e.logger.info("[action:success]",{requestId:e.requestId,duration:o-n}),t}catch(t){const r="undefined"!=typeof performance?performance.now():Date.now();throw e.logger.error("[action:error]",{requestId:e.requestId,duration:r-n,error:t instanceof Error?t.message:t}),t}};function s(e=3){return async({context:t,next:r})=>{let n;for(let o=1;o<=e;o++)try{t.logger.info("[retry:attempt]",{requestId:t.requestId,attempt:o,max:e}),t.throwIfAborted();const n=await r();return o>1&&t.logger.info("[retry:success-after-retry]",{requestId:t.requestId,attempt:o}),n}catch(e){n=e,t.logger.error("[retry:fail]",{requestId:t.requestId,attempt:o,error:e}),t.events.$emit("retry:fail",{requestId:t.requestId,attempt:o,error:e})}throw t.logger.error("[retry:exhausted]",{requestId:t.requestId,attempts:e,error:n}),n}}function c(){return"undefined"!=typeof performance?performance.now():Date.now()}const a=async({context:e,next:t})=>{const r=c(),n=e.requestId;e.logger.info("[timing:start]",{requestId:n});try{const o=await t(),s=c()-r;return e.logger.info("[timing:success]",{requestId:n,duration:s}),e.events.$emit("timing",{requestId:n,duration:s}),o}catch(t){const o=c()-r;throw e.logger.error("[timing:error]",{requestId:n,duration:o,error:t}),t}};export{e as abortMiddleware,t as auth,r as cacheMiddleware,n as eventMiddleware,o as logger,s as retry,a as timing};

package/build/esm/plugin/index.js

@@ -0,0 +1 @@
+const e={name:"auth",createContext:async()=>({auth:await Promise.resolve({userId:"user_123"})})},t={name:"cache",createContext:async()=>({cache:new Map})},s=e=>({name:"devtools",setup({app:t}){e.enabled&&t.use(async({context:e,next:t})=>await t())}}),c="__EVENT_BUS_GLOBAL_SCOPE__",o=()=>(()=>{const e=(()=>{if("undefined"!=typeof window){try{if(window.top)return window.top.location.href,window.top}catch(e){}return window}return"undefined"!=typeof globalThis?globalThis:{}})();return e[c]||Object.defineProperty(e,c,{value:{},writable:!1,enumerable:!1,configurable:!1}),e[c]})(),n="evtBusZxp_scopeZxp",a="globalZxp_defaultName",i=(e,t=a)=>{const s=`${n}__${t}`;return e[s]||(e[s]=new Map),e[s]},r="eventBusRegister_"+n,l=(e,t,s)=>{var c;if(!t||"function"!=typeof s.callback)throw Error("Event name and callback are required");const o=null!==(c=s.scopeName)&&void 0!==c?c:a,n=i(e,o);n.has(t)||n.set(t,new Set);const l=n.get(t);s.single&&l.clear(),l.forEach(e=>{e.callback===s.callback&&l.delete(e)}),l.add(Object.assign({},s)),((e,t,s=a)=>{var c;const o=null!==(c=e[r])&&void 0!==c?c:{};o[s]||(o[s]=new Set),o[s].add(t),e[r]=o})(e,t,o)};function h(e,t){let s=-1;const c=o=>{if(o<=s)return;s=o;const n=e._middlewares[o];n?n(t,()=>c(o+1)):((e,t,s=a,...c)=>{const o=i(e,s).get(t);if(!o)return;const n=Date.now();o.forEach(e=>{e.once&&e.emitted||e.timeCached&&e.timeEffect&&n-e.timeEffect<e.timeCached||(e.callback(...c),e.emitted=!0,e.timeEffect=n)})})(e._scope,t.name,t.scopeName,...t.args)};c(0)}class p{constructor(e=o()){this._middlewares=[],this._isBatching=!1,this._queue=[],this.$use=e=>{this._middlewares.push(e)},this.$batch=e=>{this._isBatching=!0;try{e()}finally{this._isBatching=!1,function(e){const t=e._queue;for(let s=0;s<t.length;s++)h(e,t[s]);t.length=0}(this)}},this.$once=(e,t)=>{l(this._scope,e,{callback:t,once:!0})},this.$on=(e,t)=>{l(this._scope,e,{callback:t,single:!0})},this.$onMultiple=(e,t)=>{l(this._scope,e,{callback:t})},this.$onCached=(e,t,s=100)=>{l(this._scope,e,{callback:t,single:!0,timeCached:s})},this.$onCachedMultiple=(e,t,s=100)=>{l(this._scope,e,{callback:t,timeCached:s})},this.$emit=(e,...t)=>{const s={scopeName:a,name:e,args:t};this._isBatching?this._queue.push(s):h(this,s)},this.$off=(e,t)=>{const s=i(this._scope,a),c=s.get(e);c&&(t?c.forEach(e=>{e.callback===t&&c.delete(e)}):s.delete(e))},this.$offAll=e=>{i(this._scope,a).delete(e)},this.$destroy=()=>{!function(e){Object.keys(e).forEach(t=>{delete e[t]})}(this._scope)},this.$clearEventAcrossScopes=e=>{const t=(()=>{var e;return null!==(e=this._scope[r])&&void 0!==e?e:{}})();Object.keys(t).forEach(s=>{var c;(null===(c=t[s])||void 0===c?void 0:c.has(e))&&i(this._scope,s).delete(e)})},this.$scopeEmit=(e,t,...s)=>{const c={scopeName:e,name:t,args:s};this._isBatching?this._queue.push(c):h(this,c)},this.$scopeOn=(e,t,s)=>{l(this._scope,t,{callback:s,single:!0,scopeName:e})},this.$scopeOnce=(e,t,s)=>{l(this._scope,t,{callback:s,once:!0,scopeName:e})},this.$scopeOnMultiple=(e,t,s)=>{l(this._scope,t,{callback:s,scopeName:e})},this.$scopeOnCached=(e,t,s,c=100)=>{l(this._scope,t,{callback:s,single:!0,timeCached:c,scopeName:e})},this.$scopeOnCachedMultiple=(e,t,s,c=100)=>{l(this._scope,t,{callback:s,timeCached:c,scopeName:e})},this.$scopeOff=(e,t,s)=>{const c=i(this._scope,e),o=c.get(t);o&&(s?o.forEach(e=>{e.callback===s&&o.delete(e)}):c.delete(t))},this.$scopeOffAll=(e,t)=>{i(this._scope,e).delete(t)},this._scope=e}}function u(e,t){return new p(Object.create(null))}const d=u(),{$once:f,$on:m,$off:$,$offAll:g,$emit:_,$onCached:b,$onMultiple:w,$onCachedMultiple:y,$clearEventAcrossScopes:v,$destroy:E,$scopeOn:O,$scopeOnce:C,$scopeOnMultiple:k,$scopeOnCached:q,$scopeOnCachedMultiple:x,$scopeEmit:I,$scopeOff:N,$scopeOffAll:M}=d,B=u(),A={name:"event",createContext:async()=>({globalEvents:B}),setup({app:e}){e.use(async({context:e,next:t})=>{const s=e.globalEvents;s.$emit("action:start",{requestId:e.requestId});try{const c=await t();return s.$emit("action:success",{requestId:e.requestId}),c}catch(t){throw s.$emit("action:error",{requestId:e.requestId,error:t}),t}})}},S={name:"logger",createContext:async()=>({logger:{info:console.log,error:console.error}})},j={name:"logger",setup({app:e}){e.use(async({context:e,next:t})=>{const s="undefined"!=typeof performance?performance.now():Date.now(),c=e.requestId;e.logger.info("[action:start]",{requestId:c});const o=e.globalEvents;o?.$emit?.("action:start",{requestId:c});try{const n=await t(),a="undefined"!=typeof performance?performance.now():Date.now();return e.logger.info("[action:success]",{requestId:c,duration:a-s}),o?.$emit?.("action:success",{requestId:c,duration:a-s}),n}catch(t){const n="undefined"!=typeof performance?performance.now():Date.now();throw e.logger.error("[action:error]",{requestId:c,duration:n-s,error:t}),o?.$emit?.("action:error",{requestId:c,error:t}),t}})},createContext:async()=>({logger:{info:console.log,error:console.error},globalEvents:u()})};export{e as authPlugin,t as cachePlugin,s as devtoolsPlugin,A as eventPlugin,B as globalEvents,j as loggerAdvancePlugin,S as loggerPlugin};

package/build/esm/react/index.js

@@ -0,0 +1 @@
+import{jsx as e}from"react/jsx-runtime";import t,{createContext as c,useContext as n,useRef as o,useState as s,useMemo as i}from"react";const r=c(null);function a(t){return e(r.Provider,{value:t.app,children:t.children})}function l(){const e=n(r);if(!e)throw Error("Missing RuntimeProvider");return e}const h="__EVENT_BUS_GLOBAL_SCOPE__",u=()=>(()=>{const e=(()=>{if("undefined"!=typeof window){try{if(window.top)return window.top.location.href,window.top}catch(e){}return window}return"undefined"!=typeof globalThis?globalThis:{}})();return e[h]||Object.defineProperty(e,h,{value:{},writable:!1,enumerable:!1,configurable:!1}),e[h]})(),p="evtBusZxp_scopeZxp",f="globalZxp_defaultName",d=(e,t=f)=>{const c=`${p}__${t}`;return e[c]||(e[c]=new Map),e[c]},m="eventBusRegister_"+p,_=(e,t,c)=>{var n;if(!t||"function"!=typeof c.callback)throw Error("Event name and callback are required");const o=null!==(n=c.scopeName)&&void 0!==n?n:f,s=d(e,o);s.has(t)||s.set(t,new Set);const i=s.get(t);c.single&&i.clear(),i.forEach(e=>{e.callback===c.callback&&i.delete(e)}),i.add(Object.assign({},c)),((e,t,c=f)=>{var n;const o=null!==(n=e[m])&&void 0!==n?n:{};o[c]||(o[c]=new Set),o[c].add(t),e[m]=o})(e,t,o)};function $(e,t){let c=-1;const n=o=>{if(o<=c)return;c=o;const s=e._middlewares[o];s?s(t,()=>n(o+1)):((e,t,c=f,...n)=>{const o=d(e,c).get(t);if(!o)return;const s=Date.now();o.forEach(e=>{e.once&&e.emitted||e.timeCached&&e.timeEffect&&s-e.timeEffect<e.timeCached||(e.callback(...n),e.emitted=!0,e.timeEffect=s)})})(e._scope,t.name,t.scopeName,...t.args)};n(0)}class b{constructor(e=u()){this._middlewares=[],this._isBatching=!1,this._queue=[],this.$use=e=>{this._middlewares.push(e)},this.$batch=e=>{this._isBatching=!0;try{e()}finally{this._isBatching=!1,function(e){const t=e._queue;for(let c=0;c<t.length;c++)$(e,t[c]);t.length=0}(this)}},this.$once=(e,t)=>{_(this._scope,e,{callback:t,once:!0})},this.$on=(e,t)=>{_(this._scope,e,{callback:t,single:!0})},this.$onMultiple=(e,t)=>{_(this._scope,e,{callback:t})},this.$onCached=(e,t,c=100)=>{_(this._scope,e,{callback:t,single:!0,timeCached:c})},this.$onCachedMultiple=(e,t,c=100)=>{_(this._scope,e,{callback:t,timeCached:c})},this.$emit=(e,...t)=>{const c={scopeName:f,name:e,args:t};this._isBatching?this._queue.push(c):$(this,c)},this.$off=(e,t)=>{const c=d(this._scope,f),n=c.get(e);n&&(t?n.forEach(e=>{e.callback===t&&n.delete(e)}):c.delete(e))},this.$offAll=e=>{d(this._scope,f).delete(e)},this.$destroy=()=>{!function(e){Object.keys(e).forEach(t=>{delete e[t]})}(this._scope)},this.$clearEventAcrossScopes=e=>{const t=(()=>{var e;return null!==(e=this._scope[m])&&void 0!==e?e:{}})();Object.keys(t).forEach(c=>{var n;(null===(n=t[c])||void 0===n?void 0:n.has(e))&&d(this._scope,c).delete(e)})},this.$scopeEmit=(e,t,...c)=>{const n={scopeName:e,name:t,args:c};this._isBatching?this._queue.push(n):$(this,n)},this.$scopeOn=(e,t,c)=>{_(this._scope,t,{callback:c,single:!0,scopeName:e})},this.$scopeOnce=(e,t,c)=>{_(this._scope,t,{callback:c,once:!0,scopeName:e})},this.$scopeOnMultiple=(e,t,c)=>{_(this._scope,t,{callback:c,scopeName:e})},this.$scopeOnCached=(e,t,c,n=100)=>{_(this._scope,t,{callback:c,single:!0,timeCached:n,scopeName:e})},this.$scopeOnCachedMultiple=(e,t,c,n=100)=>{_(this._scope,t,{callback:c,timeCached:n,scopeName:e})},this.$scopeOff=(e,t,c)=>{const n=d(this._scope,e),o=n.get(t);o&&(c?o.forEach(e=>{e.callback===c&&o.delete(e)}):n.delete(t))},this.$scopeOffAll=(e,t)=>{d(this._scope,e).delete(t)},this._scope=e}}function g(e,t){return new b(Object.create(null))}const w=g(),{$once:y,$on:E,$off:v,$offAll:O,$emit:k,$onCached:x,$onMultiple:C,$onCachedMultiple:M,$clearEventAcrossScopes:A,$destroy:N,$scopeOn:B,$scopeOnce:j,$scopeOnMultiple:S,$scopeOnCached:q,$scopeOnCachedMultiple:P,$scopeEmit:I,$scopeOff:R,$scopeOffAll:T}=w;async function Z(e){const{middleware:t,execute:c,input:n,context:o}=e;return async function e(s){const i=t[s];if(!i)return c();let r=!1;return i({input:n,context:o,next:async()=>{if(r)throw Error("next() already called");return r=!0,e(s+1)}})}(0)}const L=g();function D(e){const t=l(),c=o(null),[n,r]=s(!1),[a,h]=s(null),u=i(()=>g(),[]);return{execute:async function(n){r(!0),h(null);const o=new AbortController;c.current=o;try{const c=await(t.createContext?.()),s=await async function(e){const{action:t,input:c,context:n}=e,o=t.retry?.attempts??1;let s;for(let e=0;e<o;e++)try{return await Z({middleware:t.middleware??[],input:c,context:n,execute:async()=>(n.throwIfAborted(),t.handler({input:c,context:n}))})}catch(e){s=e}throw s}({action:e,input:n,context:{requestId:Array.from({length:16},()=>Math.floor(16*Math.random()).toString(16)).join(""),signal:o.signal,container:t.container,cache:new Map,events:u,logger:{info:console.log,error:console.error},throwIfAborted(){if(o.signal.aborted)throw Error("Action aborted")},...c}});return s}catch(e){throw h(e),e}finally{r(!1),c.current=null}},abort:function(){c.current?.abort()},loading:n,error:a,events:u,globalEvents:L}}function G(e,c,n=w){const o=t.useRef(c);o.current=c,t.useEffect(()=>{const t=(...e)=>{o.current(...e)};return n.$on(e,t),()=>{n.$off(e,t)}},[e,n])}function U(e){return l().container.resolve(e)}export{a as RuntimeProvider,L as globalEvents,D as useAction,G as useEventBus,l as useRuntime,U as useService};

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export * from './app';
+export * from './action';

package/build/middleware/abort.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '../action/types';
+export declare const abortMiddleware: Middleware;

package/build/middleware/auth.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '../action/types';
+export declare function auth<TInput, TResult>(): Middleware<TInput, TResult>;

package/build/middleware/cache.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '../action/types';
+export declare const cacheMiddleware: Middleware;

package/build/middleware/event.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '../action/types';
+export declare const eventMiddleware: Middleware;

package/build/middleware/index.d.ts

@@ -0,0 +1,7 @@
+export * from './abort';
+export * from './auth';
+export * from './cache';
+export * from './event';
+export * from './logger';
+export * from './retry';
+export * from './timing';

package/build/middleware/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '../action/types';
+export declare const logger: Middleware;

package/build/middleware/retry.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '../action/types';
+export declare function retry<TInput, TResult>(count?: number): Middleware<TInput, TResult>;

package/build/middleware/timing.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '../action/types';
+export declare const timing: Middleware;

package/build/plugin/authPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '../app/plugin';
+export declare const authPlugin: Plugin;

package/build/plugin/cachePlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '../app/plugin';
+export declare const cachePlugin: Plugin;

package/build/plugin/devtoolsPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '../app/plugin';
+export declare const devtoolsPlugin: (options: {
+    enabled: boolean;
+}) => Plugin;

package/build/plugin/eventPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../app/plugin';
+export declare const globalEvents: import("eventbus-z").GlobalBus<Record<string, any[]>, false>;
+export declare const eventPlugin: Plugin;

package/build/plugin/index.d.ts

@@ -0,0 +1,6 @@
+export * from './authPlugin';
+export * from './cachePlugin';
+export * from './devtoolsPlugin';
+export * from './eventPlugin';
+export * from './loggerPlugin';
+export * from './loggerPlusPlugin';

package/build/plugin/loggerPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '../app/plugin';
+export declare const loggerPlugin: Plugin;

package/build/plugin/loggerPlusPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '../app/plugin';
+export declare const loggerAdvancePlugin: Plugin;

package/build/react/index.d.ts

@@ -0,0 +1,4 @@
+export * from './provider';
+export * from './useAction';
+export * from './useEventBus';
+export * from './useService';

package/build/react/provider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { RuntimeApp } from '../app/createApp';
+export declare function RuntimeProvider(props: {
+    app: RuntimeApp;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useRuntime(): RuntimeApp;

package/build/react/useAction.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeAction } from '../action/types';
+export declare const globalEvents: import("eventbus-z").GlobalBus<Record<string, any[]>, false>;
+export declare function useAction<TInput, TResult>(action: RuntimeAction<TInput, TResult>): {
+    execute: (input: TInput) => Promise<TResult>;
+    abort: () => void;
+    loading: boolean;
+    error: unknown;
+    events: import("eventbus-z").GlobalBus<Record<string, any[]>, false>;
+    globalEvents: import("eventbus-z").GlobalBus<Record<string, any[]>, false>;
+};

package/build/react/useEventBus.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeEventBus } from '../action/types';
+export declare function useEventBus(name: string, callback: (...args: any[]) => void, bus?: RuntimeEventBus): void;

package/build/react/useService.d.ts

@@ -0,0 +1,2 @@
+import type { Token } from '../app/container';
+export declare function useService<T>(token: Token<T>): T;

package/package.json

@@ -0,0 +1,130 @@
+{
+  "name": "react-runtime-pipe",
+  "version": "0.1.0",
+  "description": "A backend-style runtime for React with middleware, DI, plugins, and structured action execution.",
+  "license": "MIT",
+  "author": "Delpi.Kye",
+  "sideEffects": false,
+  "type": "module",
+  "main": "./build/cjs/index.cjs",
+  "module": "./build/esm/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/esm/index.js",
+      "require": "./build/cjs/index.cjs"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "import": "./build/esm/react/index.js",
+      "require": "./build/cjs/react/index.js"
+    },
+    "./middleware": {
+      "types": "./build/middleware/index.d.ts",
+      "import": "./build/esm/middleware/index.js",
+      "require": "./build/cjs/middleware/index.js"
+    },
+    "./plugin": {
+      "types": "./build/plugin/index.d.ts",
+      "import": "./build/esm/plugin/index.js",
+      "require": "./build/cjs/plugin/index.js"
+    }
+  },
+  "files": [
+    "build",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "rollup -c",
+    "cb": "npm run clean && npm run build",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run clean && npm run lint && npm run typecheck && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/delpikye-v/react-runtime-pipe.git"
+  },
+  "homepage": "https://github.com/delpikye-v/react-runtime-pipe#readme",
+  "bugs": {
+    "url": "https://github.com/delpikye-v/react-runtime-pipe/issues"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/delpikye-v"
+  },
+  "keywords": [
+    "react",
+    "react-runtime",
+    "runtime",
+    "execution-runtime",
+    "execution-engine",
+    "action-runtime",
+    "middleware",
+    "middleware-pipeline",
+    "plugin-system",
+    "dependency-injection",
+    "di-container",
+    "orchestration",
+    "event-driven",
+    "event-bus",
+    "frontend-runtime",
+    "react-architecture",
+    "systems-design",
+    "runtime-context",
+    "typed-actions",
+    "typescript",
+    "frontend-framework",
+    "headless-runtime",
+    "async-flow",
+    "workflow-engine",
+    "react-hooks",
+    "react-state",
+    "react-patterns",
+    "state-orchestration",
+    "frontend-infrastructure",
+    "app-runtime",
+    "framework-agnostic"
+  ],
+  "peerDependencies": {
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19"
+  },
+  "dependencies": {
+    "eventbus-z": "^2.4.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/node": "^25.5.0",
+    "@types/react": "^18.2.38",
+    "@types/react-dom": "^18.2.15",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-simple-import-sort": "^13.0.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "prettier": "^3.8.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.12.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "rollup-plugin-typescript2": "^0.37.0",
+    "tslib": "^2.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}