@delpi/react-struct-z 1.0.0-alz

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 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,216 @@
+## 🏗️ @delpi/react-struct-z
+
+---
+
+[![NPM](https://img.shields.io/npm/v/@delpi/react-struct-z.svg)](https://www.npmjs.com/package/@delpi/react-struct-z)
+![Downloads](https://img.shields.io/npm/dt/@delpi/react-struct-z.svg)
+
+
+[Live Demo](https://codesandbox.io/p/sandbox/c8l2pf)
+
+---
+
+## 🌟 Description
+
+- @delpi/react-struct-z is a frontend runtime framework combining:
+- React-style composable UI - module – controller – service – DI – lifecycle
+- It provides a runtime orchestration layer for intents, effects, reactive stores, DI, and plugins, keeping business logic separate from UI.
+
+> Think of it as: “Frontend behavior runtime, modular & testable.”
+
+---
+
+## ✨ When to Use
+
++ Business logic should not live inside UI components
++ UI only emits intents, does not orchestrate logic
++ Complex async flows or multiple side effects
++ Headless, testable without rendering React
++ Multi-module, multi-engine architecture
++ Following DDD, hexagonal, or layered frontend architecture
+
+---
+
+## 📦 Installation
+```ts
+npm install @delpi/react-struct-z
+```
+
+---
+
+## 🧩 Mental Model
+```bash
+UI Layer (React)
+ └─ emits intents
+      ↓
+AppRuntime (FE Struct Framework)
+ ├─ DI Container
+ ├─ IntentBus + Middleware
+ ├─ EffectManager
+ ├─ Store (Reactive Runtime)
+ ├─ Module System
+ └─ Plugin System
+```
+
+---
+
+## 🚀 Basic Usage (Headless)
+
+#### 1️⃣ Basic Headless Example
+```ts
+// counter.store.ts
+import { Store } from "@delpi/react-struct-z"
+export const counterStore = new Store({ value: 0 })
+
+// counter.module.ts
+export const CounterModule = {
+  setup(app: any) {
+    app.intent.on("counter/inc", () => {
+      counterStore.set({ value: counterStore.get().value + 1 })
+    })
+  }
+}
+
+// app.ts
+import { AppRuntime, loadRemotePlugin } from "@delpi/react-struct-z"
+import { CounterModule } from "./counter.module"
+export const app = new AppRuntime()
+CounterModule.setup(app)
+
+// Async + Remote Plugin (if needed)
+// await loadRemotePlugin({
+//   url: "https://cdn.myapp.com/remote-logger.js"
+// }).then(plugin => app.use(plugin))
+
+// Dispatch
+app.intent.dispatch({ type: "counter/inc" })
+console.log(counterStore.get().value) // 1
+```
+
+> ✅ Quick start, headless, testable, no DI.
+
+----
+
+#### 2️⃣ React Integration Example
+
+```ts
+// counter.store.ts
+import { Store } from "@delpi/react-struct-z"
+export const counterStore = new Store({ value: 0 })
+
+// counter.service.ts
+import { counterStore } from "./counter.store"
+// Injectable is currently no-op
+export class CounterService {
+  constructor(private store = counterStore) {} // manual DI
+  increment() {
+    this.store.set({ value: this.store.get().value + 1 })
+  }
+}
+
+// counter.module.ts
+import { CounterService } from "./counter.service"
+import { counterStore } from "./counter.store"
+
+export const CounterModule = {
+  name: "counter",
+  setup(app: any) {
+    // Resolve service manually from container
+    const service = app.container.resolve(CounterService)
+
+    // Namespaced intent
+    app.intent.on("counter/inc", () => service.increment())
+  }
+}
+
+// app.ts
+import { AppRuntime } from "@delpi/react-struct-z"
+import { CounterModule } from "./counter.module"
+
+// Create runtime
+export const app = new AppRuntime()
+
+// Optionally register service in container
+app.container.provide(CounterService, () => new CounterService())
+
+// Setup module
+CounterModule.setup(app)
+
+// Headless dispatch
+app.intent.dispatch({ type: "counter/inc" })
+console.log("Counter value:", app.container.resolve(CounterService)["store"].get().value)
+
+// CounterView.tsx
+import React from "react"
+import { useStore, useIntent } from "@delpi/react-struct-z"
+import { counterStore } from "./counter.store"
+
+export function CounterView() {
+  const state = useStore(counterStore)
+  const dispatch = useIntent("counter") // namespaced
+
+  return (
+    <button onClick={() => dispatch({ type: "counter/inc" })}>
+      Count: {state.value}
+    </button>
+  )
+}
+
+// main.tsx
+import React from "react"
+import { createRoot } from "react-dom/client"
+import { RuntimeProvider } from "@delpi/react-struct-z"
+import { app } from "./app"
+import { CounterView } from "./CounterView"
+
+createRoot(document.getElementById("root")!).render(
+  <RuntimeProvider runtime={app}>
+    <CounterView />
+  </RuntimeProvider>
+)
+```
+> ✅ Full React integration, composable UI, runtime orchestration + store + intent.
+
+---
+
+## 🧪 Testing Example
+```ts
+import { AppRuntime, Store } from "@delpi/react-struct-z"
+
+test("counter increments", () => {
+  const app = new AppRuntime()
+  const store = new Store({ value: 0 })
+
+  app.intent.on("inc", () => store.set({ value: store.get().value + 1 }))
+
+  app.intent.dispatch({ type: "inc" })
+  app.intent.dispatch({ type: "inc" })
+
+  expect(store.get().value).toBe(2)
+})
+```
+
+---
+
+## ⚙️ Key Features
+| Feature / Capability         | FE Struct Framework         | Next.js                            | Remix                     | Gatsby                   |
+| ---------------------------- | --------------------------  | ---------------------------------- | ------------------------  | ------------------------ |
+| React-oriented               | ✅ Full React               | ✅ Full React                      | ✅ Full React             | ✅ Full React             |
+| Intent / Action-based        | ✅ Scoped intents           | ❌                                 | ❌                        | ❌                        |
+| Async flows built-in         | ✅ Built-in + effects       | ⚠️ Needs fetcher / hooks           | ⚠️ Needs fetcher / hooks  | ⚠️ Needs fetcher / hooks  |
+| Side effects management      | ✅ First-class              | ⚠️ Via React hooks                 | ⚠️ Via React hooks        | ⚠️ Via React hooks        |
+| Reactive Store               | ✅ Store + computed         | ❌ Only React state                | ❌ Only React state       | ❌ Only React state       |
+| Module System / DI           | ✅ Modules + lifecycle + DI | ❌ Not supported                   | ❌ Not supported          | ❌ Not supported          |
+| Computed / Derived state     | ✅ Sync + Async             | ❌ Only via useMemo / custom hooks | ❌                        | ❌                        |
+| Scoped / Namespaced Intents  | ✅ Yes                      | ❌                                 | ❌                        | ❌                        |
+| Headless / Testable          | ✅ Fully headless           | ⚠️ Needs mock SSR                  | ⚠️ Needs mock SSR         | ⚠️ Needs mock SSR         |
+| Routing / Navigation         | ❌ Not supported            | ✅ Built-in                        | ✅ Built-in               | ✅ Built-in               |
+| SSR / SSG                    | ❌ Not supported            | ✅ Built-in                        | ✅ Built-in               | ✅ Built-in               |
+| Rendering Layer              | ❌ Not supported            | ✅ Full rendering                  | ✅ Full rendering         | ✅ Full rendering         |
+| Build / Bundling             | ❌ Not included             | ✅ Built-in                        | ✅ Built-in               | ✅ Built-in               |
+
+---
+
+## 📜 License
+
+MIT

package/build/app/AppRuntime.d.ts

@@ -0,0 +1,20 @@
+import { Container } from "@/di/container";
+import { IntentBus } from "@/intent/IntentBus";
+import { EffectManager } from "@/effect/EffectManager";
+import { RuntimePlugin } from "@/plugin/Plugin";
+import { Module } from "@/module/types";
+export declare class AppRuntime {
+    container: Container;
+    intent: IntentBus;
+    effect: EffectManager;
+    private modules;
+    use(plugin: RuntimePlugin): void;
+    $on: (type: string, handler: Function) => void;
+    $emit: (intent: import("..").Intent) => Promise<void>;
+    $onIntent: (scope: string, type: string, handler: Function) => void;
+    $emitIntent: (scope: string, type: string, payload?: any) => Promise<void>;
+    useModule(module: Module): void;
+    initModules(): Promise<void>;
+    destroyModules(): void;
+    getModule<T extends Module = Module>(name: string): T | undefined;
+}

package/build/app/createApp.d.ts

@@ -0,0 +1,2 @@
+import { AppRuntime } from "./AppRuntime";
+export declare function createApp(): AppRuntime;

package/build/core/types.d.ts

@@ -0,0 +1 @@
+export type Constructor<T = any> = new (...args: any[]) => T;

package/build/di/container.d.ts

@@ -0,0 +1,5 @@
+import { Constructor } from "@/core/types";
+export declare class Container {
+    private instances;
+    resolve<T>(token: Constructor<T>): T;
+}

package/build/di/injectable.d.ts

@@ -0,0 +1 @@
+export declare function Injectable(): () => void;

package/build/effect/EffectManager.d.ts

@@ -0,0 +1,3 @@
+export declare class EffectManager {
+    run(effect: () => Promise<any>): Promise<any>;
+}

package/build/effect/types.d.ts

@@ -0,0 +1 @@
+export type Effect<T = any> = () => Promise<T>;

package/build/index.cjs.js

@@ -0,0 +1 @@
+"use strict";require("reflect-metadata");var t=require("react"),e=require("react/jsx-runtime");class s{constructor(){this.instances=new Map}resolve(t){if(!this.instances.has(t)){const e=(Reflect.getMetadata("design:paramtypes",t)||[]).map(t=>this.resolve(t));this.instances.set(t,new t(...e))}return this.instances.get(t)}}class n{constructor(){this.handlers=new Map,this.middlewares=[]}use(t){this.middlewares.push(t)}on(t,e){const s=this.handlers.get(t)||[];s.push(e),this.handlers.set(t,s)}async dispatch(t){const e={intent:t,metadata:{}};let s=-1;const n=async i=>{var o;if(i<=s)throw new Error("next() called multiple times");s=i;const r=this.middlewares[i];r?await r(e,()=>n(i+1)):null===(o=this.handlers.get(t.type))||void 0===o||o.forEach(e=>e(t))};await n(0)}onScoped(t,e,s){return this.on(`${t}/${e}`,s)}dispatchScoped(t,e,s){return this.dispatch({type:`${t}/${e}`,payload:s})}}class i{async run(t){return t()}}class o{constructor(){this.container=new s,this.intent=new n,this.effect=new i,this.modules=new Map,this.$on=this.intent.on.bind(this.intent),this.$emit=this.intent.dispatch.bind(this.intent),this.$onIntent=this.intent.onScoped.bind(this.intent),this.$emitIntent=this.intent.dispatchScoped.bind(this.intent)}use(t){t.setup(this)}useModule(t){this.modules.set(t.name,t)}async initModules(){this.modules.forEach(t=>{var e,s;null===(e=t.dependencies)||void 0===e||e.forEach(e=>{var s;const n=this.modules.get(e);null===(s=null==n?void 0:n.onModuleLoaded)||void 0===s||s.call(n,t)}),t.setup(this),null===(s=t.onInit)||void 0===s||s.call(t,this)})}destroyModules(){this.modules.forEach(t=>{var e;return null===(e=t.onDestroy)||void 0===e?void 0:e.call(t)})}getModule(t){return this.modules.get(t)}}const r=t.createContext(null),a=()=>{const e=t.useContext(r);if(!e)throw new Error("No Runtime");return e};exports.AppRuntime=o,exports.Module=function(t){return function(e){e.__moduleOptions=t}},exports.ObservabilityPlugin=class{setup(t){t.intent.use(async(t,e)=>{const s=performance.now();try{await e(),console.log("[Intent]",t.intent.type,"OK",performance.now()-s)}catch(e){throw console.error("[Intent]",t.intent.type,"ERR",e),e}})}},exports.RuntimeProvider=({runtime:t,children:s})=>e.jsx(r.Provider,{value:t,children:s}),exports.Store=class{constructor(t){this.state=t,this.listeners=new Set,this.computedMap=new Map,this.asyncComputedMap=new Map,this.asyncComputedCache=new Map}get(){return this.state}set(t){this.state=Object.assign(Object.assign({},this.state),t),this.updateComputed(),this.listeners.forEach(t=>t(this.state))}subscribe(t){return this.listeners.add(t),()=>this.listeners.delete(t)}computed(t,e){this.computedMap.set(t,e)}computedAsync(t,e){this.asyncComputedMap.set(t,e),this.updateAsyncComputed(t)}getComputed(t){var e,s;return null!==(s=null===(e=this.computedMap.get(t))||void 0===e?void 0:e(this.state))&&void 0!==s?s:this.asyncComputedCache.get(t)}updateComputed(){this.computedMap.forEach((t,e)=>t(this.state))}async updateAsyncComputed(t){const e=this.asyncComputedMap.get(t);if(e){const s=await e(this.state);this.asyncComputedCache.set(t,s),this.listeners.forEach(t=>t(this.state))}}},exports.createApp=function(){return new o},exports.createModule=function(t){return t},exports.createPluginContext=function(t){return{intent:{tap(e){t.intent.use(async(t,s)=>{e(t.intent),await s()})}},effect:{track(t){}},store:{observe(t){}}}},exports.loadRemotePlugin=async function(t){const e=await import(t.url),s=t.exportName?e[t.exportName]:e.default;if(!s)throw new Error(`Remote plugin not found: ${t.exportName||"default"}`);const n="function"==typeof s?new s:s;if(!n.manifest||!n.setup)throw new Error("Invalid RuntimePlugin");return n},exports.useComputed=function(e,s){return t.useSyncExternalStore(e.subscribe.bind(e),()=>e.getComputed(s))},exports.useEffectIntent=function(t,e){const s=a();return()=>s.intent.dispatch({type:t,payload:e})},exports.useIntent=function(t){const e=a();return s=>{const n=t?`${t}/${s.type}`:s.type;e.intent.dispatch({type:n,payload:s.payload})}},exports.useModule=function(t){return a().container.resolve(t)},exports.useRuntime=a,exports.useStore=function(e){return t.useSyncExternalStore(e.subscribe.bind(e),()=>e.get())};

package/build/index.d.ts

@@ -0,0 +1,21 @@
+import "reflect-metadata";
+export { createApp } from "@/app/createApp";
+export { AppRuntime } from "@/app/AppRuntime";
+export { createModule } from "@/module/createModule";
+export type { Module as ModuleType } from "@/module/types";
+export { Module } from "@/module/decorator";
+export type { ModuleOptions } from "@/module/decorator";
+export type { Intent } from "@/intent/types";
+export type { IntentMiddleware } from "@/intent/middleware";
+export { Store } from "@/store/Store";
+export { useStore } from "@/store/useStore";
+export { loadRemotePlugin } from "@/plugin/remote/remotePluginLoader";
+export type { RemotePluginConfig } from "@/plugin/remote/remotePluginLoader";
+export type { RuntimePlugin } from "@/plugin/Plugin";
+export type { PluginContext } from "@/plugin/PluginContext";
+export type { PluginManifest, PluginCapability } from "@/plugin/PluginManifest";
+export { createPluginContext } from "@/plugin/createPluginContext";
+export { ObservabilityPlugin } from "@/plugin/observability";
+export { RuntimeProvider, useRuntime } from "@/react/RuntimeProvider";
+export { useIntent } from "@/react/useIntent";
+export { useComputed, useEffectIntent, useModule } from "@/react/hooks";

package/build/index.esm.js

@@ -0,0 +1 @@
+import"reflect-metadata";import{useSyncExternalStore as t,createContext as e,useContext as n}from"react";import{jsx as s}from"react/jsx-runtime";class i{constructor(){this.instances=new Map}resolve(t){if(!this.instances.has(t)){const e=(Reflect.getMetadata("design:paramtypes",t)||[]).map(t=>this.resolve(t));this.instances.set(t,new t(...e))}return this.instances.get(t)}}class o{constructor(){this.handlers=new Map,this.middlewares=[]}use(t){this.middlewares.push(t)}on(t,e){const n=this.handlers.get(t)||[];n.push(e),this.handlers.set(t,n)}async dispatch(t){const e={intent:t,metadata:{}};let n=-1;const s=async i=>{var o;if(i<=n)throw new Error("next() called multiple times");n=i;const a=this.middlewares[i];a?await a(e,()=>s(i+1)):null===(o=this.handlers.get(t.type))||void 0===o||o.forEach(e=>e(t))};await s(0)}onScoped(t,e,n){return this.on(`${t}/${e}`,n)}dispatchScoped(t,e,n){return this.dispatch({type:`${t}/${e}`,payload:n})}}class a{async run(t){return t()}}class r{constructor(){this.container=new i,this.intent=new o,this.effect=new a,this.modules=new Map,this.$on=this.intent.on.bind(this.intent),this.$emit=this.intent.dispatch.bind(this.intent),this.$onIntent=this.intent.onScoped.bind(this.intent),this.$emitIntent=this.intent.dispatchScoped.bind(this.intent)}use(t){t.setup(this)}useModule(t){this.modules.set(t.name,t)}async initModules(){this.modules.forEach(t=>{var e,n;null===(e=t.dependencies)||void 0===e||e.forEach(e=>{var n;const s=this.modules.get(e);null===(n=null==s?void 0:s.onModuleLoaded)||void 0===n||n.call(s,t)}),t.setup(this),null===(n=t.onInit)||void 0===n||n.call(t,this)})}destroyModules(){this.modules.forEach(t=>{var e;return null===(e=t.onDestroy)||void 0===e?void 0:e.call(t)})}getModule(t){return this.modules.get(t)}}function c(){return new r}function u(t){return t}function h(t){return function(e){e.__moduleOptions=t}}class d{constructor(t){this.state=t,this.listeners=new Set,this.computedMap=new Map,this.asyncComputedMap=new Map,this.asyncComputedCache=new Map}get(){return this.state}set(t){this.state=Object.assign(Object.assign({},this.state),t),this.updateComputed(),this.listeners.forEach(t=>t(this.state))}subscribe(t){return this.listeners.add(t),()=>this.listeners.delete(t)}computed(t,e){this.computedMap.set(t,e)}computedAsync(t,e){this.asyncComputedMap.set(t,e),this.updateAsyncComputed(t)}getComputed(t){var e,n;return null!==(n=null===(e=this.computedMap.get(t))||void 0===e?void 0:e(this.state))&&void 0!==n?n:this.asyncComputedCache.get(t)}updateComputed(){this.computedMap.forEach((t,e)=>t(this.state))}async updateAsyncComputed(t){const e=this.asyncComputedMap.get(t);if(e){const n=await e(this.state);this.asyncComputedCache.set(t,n),this.listeners.forEach(t=>t(this.state))}}}function p(e){return t(e.subscribe.bind(e),()=>e.get())}async function l(t){const e=await import(t.url),n=t.exportName?e[t.exportName]:e.default;if(!n)throw new Error(`Remote plugin not found: ${t.exportName||"default"}`);const s="function"==typeof n?new n:n;if(!s.manifest||!s.setup)throw new Error("Invalid RuntimePlugin");return s}function m(t){return{intent:{tap(e){t.intent.use(async(t,n)=>{e(t.intent),await n()})}},effect:{track(t){}},store:{observe(t){}}}}class f{setup(t){t.intent.use(async(t,e)=>{const n=performance.now();try{await e(),console.log("[Intent]",t.intent.type,"OK",performance.now()-n)}catch(e){throw console.error("[Intent]",t.intent.type,"ERR",e),e}})}}const y=e(null),w=({runtime:t,children:e})=>s(y.Provider,{value:t,children:e}),v=()=>{const t=n(y);if(!t)throw new Error("No Runtime");return t};function g(t){const e=v();return n=>{const s=t?`${t}/${n.type}`:n.type;e.intent.dispatch({type:s,payload:n.payload})}}function M(t){return v().container.resolve(t)}function b(t,e){const n=v();return()=>n.intent.dispatch({type:t,payload:e})}function C(e,n){return t(e.subscribe.bind(e),()=>e.getComputed(n))}export{r as AppRuntime,h as Module,f as ObservabilityPlugin,w as RuntimeProvider,d as Store,c as createApp,u as createModule,m as createPluginContext,l as loadRemotePlugin,C as useComputed,b as useEffectIntent,g as useIntent,M as useModule,v as useRuntime,p as useStore};

package/build/index.umd.min.js

@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("reflect-metadata"),require("react"),require("react/jsx-runtime")):"function"==typeof define&&define.amd?define(["exports","reflect-metadata","react","react/jsx-runtime"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).ReactStruct={},null,t.react,t.jsxRuntime)}(this,function(t,e,n,s){"use strict";class i{constructor(){this.instances=new Map}resolve(t){if(!this.instances.has(t)){const e=(Reflect.getMetadata("design:paramtypes",t)||[]).map(t=>this.resolve(t));this.instances.set(t,new t(...e))}return this.instances.get(t)}}class o{constructor(){this.handlers=new Map,this.middlewares=[]}use(t){this.middlewares.push(t)}on(t,e){const n=this.handlers.get(t)||[];n.push(e),this.handlers.set(t,n)}async dispatch(t){const e={intent:t,metadata:{}};let n=-1;const s=async i=>{var o;if(i<=n)throw new Error("next() called multiple times");n=i;const a=this.middlewares[i];a?await a(e,()=>s(i+1)):null===(o=this.handlers.get(t.type))||void 0===o||o.forEach(e=>e(t))};await s(0)}onScoped(t,e,n){return this.on(`${t}/${e}`,n)}dispatchScoped(t,e,n){return this.dispatch({type:`${t}/${e}`,payload:n})}}class a{async run(t){return t()}}class r{constructor(){this.container=new i,this.intent=new o,this.effect=new a,this.modules=new Map,this.$on=this.intent.on.bind(this.intent),this.$emit=this.intent.dispatch.bind(this.intent),this.$onIntent=this.intent.onScoped.bind(this.intent),this.$emitIntent=this.intent.dispatchScoped.bind(this.intent)}use(t){t.setup(this)}useModule(t){this.modules.set(t.name,t)}async initModules(){this.modules.forEach(t=>{var e,n;null===(e=t.dependencies)||void 0===e||e.forEach(e=>{var n;const s=this.modules.get(e);null===(n=null==s?void 0:s.onModuleLoaded)||void 0===n||n.call(s,t)}),t.setup(this),null===(n=t.onInit)||void 0===n||n.call(t,this)})}destroyModules(){this.modules.forEach(t=>{var e;return null===(e=t.onDestroy)||void 0===e?void 0:e.call(t)})}getModule(t){return this.modules.get(t)}}const u=n.createContext(null),c=()=>{const t=n.useContext(u);if(!t)throw new Error("No Runtime");return t};t.AppRuntime=r,t.Module=function(t){return function(e){e.__moduleOptions=t}},t.ObservabilityPlugin=class{setup(t){t.intent.use(async(t,e)=>{const n=performance.now();try{await e(),console.log("[Intent]",t.intent.type,"OK",performance.now()-n)}catch(e){throw console.error("[Intent]",t.intent.type,"ERR",e),e}})}},t.RuntimeProvider=({runtime:t,children:e})=>s.jsx(u.Provider,{value:t,children:e}),t.Store=class{constructor(t){this.state=t,this.listeners=new Set,this.computedMap=new Map,this.asyncComputedMap=new Map,this.asyncComputedCache=new Map}get(){return this.state}set(t){this.state=Object.assign(Object.assign({},this.state),t),this.updateComputed(),this.listeners.forEach(t=>t(this.state))}subscribe(t){return this.listeners.add(t),()=>this.listeners.delete(t)}computed(t,e){this.computedMap.set(t,e)}computedAsync(t,e){this.asyncComputedMap.set(t,e),this.updateAsyncComputed(t)}getComputed(t){var e,n;return null!==(n=null===(e=this.computedMap.get(t))||void 0===e?void 0:e(this.state))&&void 0!==n?n:this.asyncComputedCache.get(t)}updateComputed(){this.computedMap.forEach((t,e)=>t(this.state))}async updateAsyncComputed(t){const e=this.asyncComputedMap.get(t);if(e){const n=await e(this.state);this.asyncComputedCache.set(t,n),this.listeners.forEach(t=>t(this.state))}}},t.createApp=function(){return new r},t.createModule=function(t){return t},t.createPluginContext=function(t){return{intent:{tap(e){t.intent.use(async(t,n)=>{e(t.intent),await n()})}},effect:{track(t){}},store:{observe(t){}}}},t.loadRemotePlugin=async function(t){const e=await import(t.url),n=t.exportName?e[t.exportName]:e.default;if(!n)throw new Error(`Remote plugin not found: ${t.exportName||"default"}`);const s="function"==typeof n?new n:n;if(!s.manifest||!s.setup)throw new Error("Invalid RuntimePlugin");return s},t.useComputed=function(t,e){return n.useSyncExternalStore(t.subscribe.bind(t),()=>t.getComputed(e))},t.useEffectIntent=function(t,e){const n=c();return()=>n.intent.dispatch({type:t,payload:e})},t.useIntent=function(t){const e=c();return n=>{const s=t?`${t}/${n.type}`:n.type;e.intent.dispatch({type:s,payload:n.payload})}},t.useModule=function(t){return c().container.resolve(t)},t.useRuntime=c,t.useStore=function(t){return n.useSyncExternalStore(t.subscribe.bind(t),()=>t.get())}});

package/build/intent/IntentBus.d.ts

@@ -0,0 +1,11 @@
+import { Intent } from "./types";
+import { IntentMiddleware } from "./middleware";
+export declare class IntentBus {
+    private handlers;
+    private middlewares;
+    use(mw: IntentMiddleware): void;
+    on(type: string, handler: Function): void;
+    dispatch(intent: Intent): Promise<void>;
+    onScoped(scope: string, type: string, handler: Function): void;
+    dispatchScoped(scope: string, type: string, payload?: any): Promise<void>;
+}

package/build/intent/middleware.d.ts

@@ -0,0 +1,6 @@
+import { Intent } from "./types";
+export type IntentContext = {
+    intent: Intent;
+    metadata: Record<string, any>;
+};
+export type IntentMiddleware = (ctx: IntentContext, next: () => Promise<void>) => Promise<void>;

package/build/intent/types.d.ts

@@ -0,0 +1,4 @@
+export interface Intent<T = any> {
+    type: string;
+    payload?: T;
+}

package/build/module/ModuleLoader.d.ts

@@ -0,0 +1,2 @@
+import { AppRuntime } from "@/app/AppRuntime";
+export declare function loadModule(app: AppRuntime, moduleClass: any): Promise<any>;

package/build/module/createModule.d.ts

@@ -0,0 +1,4 @@
+import { AppRuntime } from "@/app/AppRuntime";
+import { Module } from "./types";
+export declare function createModule(module: Module): Module;
+export declare function initModule(app: AppRuntime, module: Module): void;

package/build/module/decorator.d.ts

@@ -0,0 +1,5 @@
+export interface ModuleOptions {
+    imports?: any[];
+    providers?: any[];
+}
+export declare function Module(options: ModuleOptions): (constructor: any) => void;

package/build/module/types.d.ts

@@ -0,0 +1,9 @@
+import { AppRuntime } from "@/app/AppRuntime";
+export interface Module {
+    name: string;
+    dependencies?: string[];
+    setup(app: AppRuntime): void;
+    onInit?(app: AppRuntime): void;
+    onDestroy?(): void;
+    onModuleLoaded?(depModule: any): void;
+}

package/build/plugin/Plugin.d.ts

@@ -0,0 +1,5 @@
+import { AppRuntime } from "@/app/AppRuntime";
+export interface RuntimePlugin {
+    setup(app: AppRuntime): void;
+    teardown?(): void;
+}

package/build/plugin/PluginContext.d.ts

@@ -0,0 +1,12 @@
+import { Intent } from "@/intent/types";
+export interface PluginContext {
+    intent: {
+        tap(fn: (intent: Intent) => void): void;
+    };
+    effect: {
+        track(fn: (name: string, duration: number) => void): void;
+    };
+    store: {
+        observe(fn: (storeId: string, nextState: any) => void): void;
+    };
+}

package/build/plugin/PluginManager.d.ts

@@ -0,0 +1,6 @@
+import { RuntimePlugin } from "./RuntimePlugin";
+export declare class PluginManager {
+    private plugins;
+    register(plugin: RuntimePlugin): void;
+    list(): import("./PluginManifest").PluginManifest[];
+}

package/build/plugin/PluginManifest.d.ts

@@ -0,0 +1,17 @@
+export type PluginCapability = "intent" | "effect" | "store" | "ui" | "devtools";
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    homepage?: string;
+    license?: string;
+    capabilities: PluginCapability[];
+    runtime: {
+        minVersion: string;
+    };
+    pricing?: {
+        type: "free" | "paid" | "trial";
+    };
+}

package/build/plugin/RuntimePlugin.d.ts

@@ -0,0 +1,7 @@
+import { AppRuntime } from "@/app/AppRuntime";
+import { PluginManifest } from "./PluginManifest";
+export interface RuntimePlugin {
+    manifest: PluginManifest;
+    setup(app: AppRuntime): void;
+    teardown?(): void;
+}

package/build/plugin/createPluginContext.d.ts

@@ -0,0 +1,3 @@
+import { AppRuntime } from "@/app/AppRuntime";
+import { PluginContext } from "./PluginContext";
+export declare function createPluginContext(app: AppRuntime): PluginContext;

package/build/plugin/observability.d.ts

@@ -0,0 +1,5 @@
+import { AppRuntime } from "@/app/AppRuntime";
+import { RuntimePlugin } from "@/plugin/Plugin";
+export declare class ObservabilityPlugin implements RuntimePlugin {
+    setup(app: AppRuntime): void;
+}

package/build/plugin/remote/remotePluginLoader.d.ts

@@ -0,0 +1,6 @@
+import { RuntimePlugin } from "../RuntimePlugin";
+export type RemotePluginConfig = {
+    url: string;
+    exportName?: string;
+};
+export declare function loadRemotePlugin(config: RemotePluginConfig): Promise<RuntimePlugin>;

package/build/react/RuntimeProvider.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { AppRuntime } from "@/app/AppRuntime";
+export declare const RuntimeProvider: React.FC<{
+    runtime: AppRuntime;
+    children: React.ReactNode;
+}>;
+export declare const useRuntime: () => AppRuntime;

package/build/react/hooks.d.ts

@@ -0,0 +1,6 @@
+export declare function useModule(moduleClass: any): unknown;
+export declare function useEffectIntent(intentType: string, payload?: any): () => Promise<void>;
+export declare function useComputed<T>(store: {
+    getComputed: (key: string) => T;
+    subscribe: any;
+}, key: string): T;

package/build/react/useIntent.d.ts

@@ -0,0 +1,4 @@
+export declare function useIntent(scope?: string): (intent: {
+    type: string;
+    payload?: any;
+}) => void;

package/build/store/Store.d.ts

@@ -0,0 +1,20 @@
+type Listener<T> = (state: T) => void;
+type ComputedFn<T> = (state: T) => any;
+type AsyncComputedFn<T> = (state: T) => Promise<any>;
+export declare class Store<T> {
+    private state;
+    private listeners;
+    private computedMap;
+    private asyncComputedMap;
+    private asyncComputedCache;
+    constructor(state: T);
+    get(): T;
+    set(partial: Partial<T>): void;
+    subscribe(fn: Listener<T>): () => boolean;
+    computed(key: string, fn: ComputedFn<T>): void;
+    computedAsync(key: string, fn: AsyncComputedFn<T>): void;
+    getComputed(key: string): any;
+    private updateComputed;
+    private updateAsyncComputed;
+}
+export {};

package/build/store/useStore.d.ts

@@ -0,0 +1,2 @@
+import { Store } from "./Store";
+export declare function useStore<T>(store: Store<T>): T;

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@delpi/react-struct-z",
+  "version": "1.0.0-alz",
+  "description": "React-oriented modular framework for intent-driven orchestration, reactive store, effects, and DI-enabled modules",
+  "license": "MIT",
+  "author": "Delpi.Kye",
+  "type": "module",
+  "sideEffects": false,
+  "main": "build/index.cjs.js",
+  "module": "build/index.esm.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.esm.js",
+      "require": "./build/index.cjs.js"
+    }
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "rollup -c",
+    "cb": "npm run clean && npm run build",
+    "prepublishOnly": "npm run cb"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/delpikye-v/react-struct.git"
+  },
+  "homepage": "https://github.com/delpikye-v/react-struct#readme",
+  "bugs": {
+    "url": "https://github.com/delpikye-v/react-struct/issues"
+  },
+  "keywords": [
+    "react",
+    "react-framework",
+    "intent",
+    "intent-engine",
+    "orchestration",
+    "modular",
+    "module-system",
+    "computed-graph",
+    "state-engine",
+    "effect-pipeline",
+    "di-container",
+    "plugin-system",
+    "side-effects",
+    "async-flow",
+    "reactive-store",
+    "ddd",
+    "hexagonal",
+    "frontend-architecture"
+  ],
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+
+    "rollup": "^4.9.6",
+    "rollup-plugin-typescript2": "^0.36.0",
+
+    "typescript": "^5.3.3",
+    "tslib": "^2.6.2",
+    "rimraf": "^5.0.5",
+
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "@types/react": "^18.2.45",
+    "@types/react-dom": "^18.2.18"
+  },
+
+  "peerDependencies": {
+    "react": ">=16.8",
+    "react-dom": ">=16.8"
+  },
+
+  "dependencies": {
+    "reflect-metadata": "^0.1.13"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}