@wirestate/core 0.6.0

package/CHANGELOG.md

@@ -0,0 +1,51 @@
+## 0.6.0
+
+- Split wirestate as separate @wirestate packages
+
+## 0.5.0
+
+- Add default initial state param on creation of containers
+- Explicit typing for query callers, export new types
+- For wire-scope add missing optional query/command/resolve methods
+- Add sourcemaps in lib bundles
+- Add `signals` entry for variants of storage usage without mobx
+
+## 0.4.0
+
+- Add `OnActivated` decorator
+- Add `OnDeactivated` decorator
+- `initialState` -> `seed`
+- `type` -> `bindingType`
+- `scopeType` -> `bindingScopeType`
+- Emit events with two params instead of manually composed object, signal `from`
+- Add commands module
+- Add WireScope shared class for managing of wirestate events, queries and commands
+- Remove abstract service in favor of WireScope usage
+- Signals -> events
+- `useOptionalInjection` -> add fallback handler
+
+## 0.3.0
+
+- Rename `createServicesProvider` to `createInjectablesProvider`
+- Add `useSignals`, `useSignalHandler` hooks for better signal handling ergonomics
+- Add `useOptionalInjection` hook for safe resolution of optional dependencies
+- Support optional queries via `queryOptional`, `useOptionalQueryCaller`, and `useOptionalSyncQueryCaller`
+- Support merging of initial states when multiple providers co-exist
+- Add more re-exports from `mobx` and `inversify` for easier consumer usage
+- Improve test coverage, extend test utilities
+- Correctly notify about `IS_DISPOSED` after deactivation of services
+
+## 0.2.0
+
+- Activate and deactivate services in stack ordering
+- Portable libs will not fail with react compiler builds
+- Extend test-utils
+- Increasing test coverage
+- Error handling / custom error class
+- Allow addition of constant bindings in the IOC container
+- useService -> useInjection
+- AbstractService::getService -> AbstractService::resolve
+
+## 0.1.1
+
+- Initial release

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Syrotenko Igor
+
+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,319 @@
+# <a href='https://www.npmjs.com/package/wirestate'> ⚡ wirestate </a>
+
+[![npm version](https://img.shields.io/npm/v/wirestate.svg?style=flat-square)](https://www.npmjs.com/package/wirestate)
+[![language-ts](https://img.shields.io/badge/language-typescript-blue.svg?style=flat)](https://github.com/Neloreck/wirestate/search?l=typescript)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/Neloreck/wirestate/blob/master/LICENSE)
+
+`wirestate` is a reactivity-independent state management framework for React. It integrates **InversifyJS** for robust Dependency Injection,
+providing IOC/DI/indirection based architecture based on concepts of Services, Events, Commands, and Queries. 
+
+It optionally works with **MobX**, **Signals**, or other custom reactivity implementations.
+
+## Architecture & Core Concepts
+
+Designed for complex applications, `wirestate` enforces a clear separation of concerns:
+
+- **Services**: Singleton-scoped logic units that hold state and business logic.
+- **Dependency Injection**: First-class InversifyJS integration for decoupled, testable code.
+- **Reactivity**: Independent state tracking (optional integration with MobX, Signals, etc.).
+- **Events**: Fire-and-forget communication for cross-service side effects.
+- **Commands**: Encapsulated write operations with standardized execution status (pending, settled, error).
+- **Queries**: Synchronous or asynchronous request-response patterns for data retrieval.
+- **Lifecycle Management**: Automated services provision within react tree, activation/deactivation lifecycle. 
+
+## Requirements
+
+- `react >= 16.8.0`
+- `reflect-metadata` (must be imported at application entry)
+
+## Installation
+
+```bash
+npm install --save @wirestate/core reflect-metadata
+```
+
+### For react-mobx
+
+```bash
+npm install --save @wirestate/react @wirestate/react-mobx mobx mobx-react-lite
+```
+
+### For signals
+
+```bash
+npm install --save @wirestate/react @wirestate/react-signals @preact/signals-react
+npm install --save-dev @preact/signals-react-transform
+```
+
+## Quick Start with mobx
+
+### 1. Define a Service
+
+Services are standard classes decorated with `@Injectable`. Use `WireScope` to interact with the framework.
+
+```typescript
+import { Injectable, Inject, WireScope, OnEvent, OnCommand, OnQuery } from '@wirestate/core';
+import { makeObservable, Observable, Action } from '@wirestate/react-mobx';
+
+@Injectable()
+export class CounterService {
+  @Observable()
+  public count: number = 0;
+
+  public constructor(
+    @Inject(WireScope)
+    private scope: WireScope
+  ) {
+    makeObservable(this);
+  }
+
+  @Action()
+  public increment(amount: number = 1): void {
+    this.count += amount;
+  }
+
+  @Action()
+  public reset(): void {
+    this.count = 0;
+  }
+
+  @OnCommand('INCREMENT')
+  public onIncrementCommand(amount: number = 1): void {
+    this.increment(amount);
+  }
+
+  @OnQuery('GET_TOTAL')
+  public onGetTotal(): number {
+    return this.count;
+  }
+
+  @OnEvent('RESET')
+  public onResetEvent(): void {
+    this.reset();
+  }
+}
+```
+
+### 2. Configure the Provider
+
+Bind services at any level of the component tree.
+Lifetimes are managed automatically.
+
+```tsx
+import { IocProvider, createInjectablesProvider } from '@wirestate/react';
+import { CounterService } from './CounterService';
+
+const MainProvider = createInjectablesProvider([CounterService]);
+
+export function Application() {
+  return (
+    <IocProvider>
+      <MainProvider>
+        <CounterView />
+      </MainProvider>
+    </IocProvider>
+  );
+}
+```
+
+### 3. Consume in Components
+
+Directly use services and rely on mobx reactivity.
+Or use specialized hooks for communication without direct references.
+
+```tsx
+import { useInjection, useCommandCaller, useEventEmitter } from '@wirestate/react';
+import { observer } from '@wirestate/react-mobx';
+import { CounterService } from './CounterService';
+
+export const CounterView = observer(() => {
+  const service = useInjection(CounterService);
+  const call = useCommandCaller();
+  const emit = useEventEmitter();
+
+  return (
+    <div>
+      <p>Count: {service.count}</p>
+      <button onClick={() => service.increment(5)}>Add 1 (Method)</button>
+      <button onClick={() => call('INCREMENT', 5)}>Add 5 (Command)</button>
+      <button onClick={() => service.reset()}>Reset (Method)</button>
+      <button onClick={() => emit('RESET')}>Reset (Event)</button>
+    </div>
+  );
+});
+```
+
+## Quick Start with signals
+
+### 1. Define a Service
+
+Services use `signal` and `computed` for state management.
+
+```typescript
+import { Injectable, Inject, WireScope, OnEvent, OnCommand, OnQuery } from '@wirestate/core';
+import { signal, computed, Signal, ReadonlySignal } from '@wirestate/react-signals';
+
+@Injectable()
+export class CounterService {
+  public readonly count: Signal<number> = signal(0);
+  public readonly isEven: ReadonlySignal<boolean> = computed(() => this.count.value % 2 === 0);
+
+  public constructor(
+    @Inject(WireScope)
+    private scope: WireScope
+  ) {}
+
+  public increment(amount: number = 1): void {
+    this.count.value += amount;
+  }
+
+  public reset(): void {
+    this.count.value = 0;
+  }
+
+  @OnCommand('INCREMENT')
+  public onIncrementCommand(amount: number = 1): void {
+    this.increment(amount);
+  }
+
+  @OnQuery('GET_TOTAL')
+  public onGetTotal(): number {
+    return this.count.value;
+  }
+
+  @OnEvent('RESET')
+  public onResetEvent(): void {
+    this.reset();
+  }
+}
+```
+
+### 2. Configure the Provider
+
+The provider configuration remains the same regardless of the reactivity implementation.
+
+```tsx
+import { IocProvider, createInjectablesProvider } from '@wirestate/react';
+import { CounterService } from './CounterService';
+
+const MainProvider = createInjectablesProvider([CounterService]);
+
+export function Application() {
+  return (
+    <IocProvider>
+      <MainProvider>
+        <CounterView />
+      </MainProvider>
+    </IocProvider>
+  );
+}
+```
+
+### 3. Consume in Components
+
+Access signals directly in components. Reactivity is handled by the signals transform or manual subscription.
+
+```tsx
+import { useInjection, useCommandCaller, useEventEmitter } from '@wirestate/react';
+import { CounterService } from './CounterService';
+
+export function CounterView() {
+  const service = useInjection(CounterService);
+  const call = useCommandCaller();
+  const emit = useEventEmitter();
+
+  return (
+    <div>
+      <p>Count: {service.count}</p>
+      <p>Even: {service.isEven.value ? 'Yes' : 'No'}</p>
+      <button onClick={() => service.increment(5)}>Add 1 (Method)</button>
+      <button onClick={() => call('INCREMENT', 5)}>Add 5 (Command)</button>
+      <button onClick={() => service.reset()}>Reset (Method)</button>
+      <button onClick={() => emit('RESET')}>Reset (Event)</button>
+    </div>
+  );
+}
+```
+
+## Advanced Usage
+
+### Seeding Shared Initial State
+
+`wirestate` supports providing initial data (seeds) to services during activation.
+
+```tsx
+const MainProvider = createInjectablesProvider([CounterService]);
+
+<IocProvider>
+  <MainProvider seed={{ initialCount: 100 }}>
+    <CounterView />
+  </MainProvider>
+</IocProvider>
+```
+
+In the service:
+
+```typescript
+import { Injectable, Inject, SEED } from 'wirestate';
+
+@Injectable()
+export class CounterService {
+  // ...
+  public constructor(
+    @Inject(SEED) 
+    initialState: { initialCount: number  }
+  ) {
+    this.count = seed.initialCount;
+  }
+}
+```
+
+### Seeding Bound Initial State
+
+`wirestate` supports providing initial data (seeds) to services during activation.
+
+```tsx
+const MainProvider = createInjectablesProvider([CounterService]);
+
+<IocProvider>
+  <MainProvider seeds={[[CounterService, { count: 10 }]]}>
+    <CounterView />
+  </MainProvider>
+</IocProvider>
+```
+
+In the service:
+
+```typescript
+import { Injectable, Inject, WireScope } from 'wirestate';
+
+@Injectable()
+export class CounterService {
+  // ...
+  public constructor(@Inject(WireScope) scope: WireScope) {
+    this.count = scope.getSeed(CounterService).count;
+  }
+}
+```
+
+### Service Lifecycle
+
+Use decorators to handle initialization and cleanup.
+
+```typescript
+import { OnActivated, OnDeactivation } from 'wirestate';
+
+@OnActivated()
+public onActivated(): void {
+  // Start polling, fetch initial data, etc.
+}
+
+@OnDeactivation()
+public onDeactivation(): void {
+  // Cleanup subscriptions
+}
+```
+
+## License
+
+MIT

package/cjs/development/index.js

@@ -0,0 +1,301 @@
+'use strict';
+
+var inversify = require('inversify');
+var createIocContainer = require('./lib.js');
+var tslib = require('tslib');
+
+function forwardRef(forward) {
+  return new inversify.LazyServiceIdentifier(forward);
+}
+
+/**
+ * Dispatches a command on the provided container.
+ *
+ * @param container - inversify container
+ * @param type - command type
+ * @param data - command data
+ * @returns command descriptor
+ */
+function command(container, type, data) {
+  return container.get(createIocContainer.CommandBus).command(type, data);
+}
+
+/**
+ * Dispatches a command on the provided container, returning null if no handler is registered.
+ *
+ * @param container - inversify container
+ * @param type - command type
+ * @param data - command data
+ * @returns command descriptor or null
+ */
+function commandOptional(container, type, data) {
+  return container.get(createIocContainer.CommandBus).commandOptional(type, data);
+}
+
+/**
+ * Decorator for service methods that handle a command.
+ *
+ * @param type - command type identifier
+ * @returns decorator function
+ */
+function OnCommand(type) {
+  return function (target, propertyKey) {
+    var constructor = target.constructor;
+    var list = createIocContainer.COMMAND_HANDLER_METADATA.get(constructor);
+    if (!list) {
+      list = [];
+      createIocContainer.COMMAND_HANDLER_METADATA.set(constructor, list);
+    }
+    // Register handler metadata for prototype-based retrieval.
+    list.push({
+      methodName: propertyKey,
+      type: type
+    });
+  };
+}
+
+/**
+ * Emits events for container from outside scope.
+ *
+ * @param container - inversify container
+ * @param type - event type ot emit
+ * @param payload - event payload
+ * @param from - optional indicator of the event source
+ */
+function emitEvent(container, type, payload, from) {
+  container.get(createIocContainer.EventBus).emit({
+    type: type,
+    payload: payload,
+    from: from
+  });
+}
+
+/**
+ * Decorator for service methods that respond to events.
+ *
+ * @param types - event type(s) to handle. If omitted, handles all events
+ * @returns decorator function
+ */
+function OnEvent(types) {
+  // Normalize types to an array or null for catch-all.
+  var normalized = types === undefined ? null : Array.isArray(types) ? tslib.__spreadArray([], types, true) : [types];
+  return function (target, propertyKey) {
+    var constructor = target.constructor;
+    var list = createIocContainer.EVENT_HANDLER_METADATA.get(constructor);
+    if (!list) {
+      list = [];
+      createIocContainer.EVENT_HANDLER_METADATA.set(constructor, list);
+    }
+    // Register handler metadata for prototype-based retrieval.
+    list.push({
+      methodName: propertyKey,
+      types: normalized
+    });
+  };
+}
+
+/**
+ * Dispatches a query on the provided container.
+ *
+ * @param container - inversify container
+ * @param type - query type
+ * @param data - query data
+ * @returns query result
+ */
+function query(container, type, data) {
+  return container.get(createIocContainer.QueryBus).query(type, data);
+}
+
+/**
+ * Dispatches a query on the provided container, returning null if no handler is registered.
+ *
+ * @param container - inversify container
+ * @param type - query type
+ * @param data - query data
+ * @returns query result or null
+ */
+function queryOptional(container, type, data) {
+  return container.get(createIocContainer.QueryBus).queryOptional(type, data);
+}
+
+/**
+ * Decorator for service methods that respond to a query.
+ *
+ * @param type - query type identifier
+ * @returns decorator function
+ */
+function OnQuery(type) {
+  return function (target, propertyKey) {
+    var constructor = target.constructor;
+    var list = createIocContainer.QUERY_HANDLER_METADATA.get(constructor);
+    if (!list) {
+      list = [];
+      createIocContainer.QUERY_HANDLER_METADATA.set(constructor, list);
+    }
+    // Register handler metadata for prototype-based retrieval.
+    list.push({
+      methodName: propertyKey,
+      type: type
+    });
+  };
+}
+
+/**
+ * Applies seeds to the container into the existing instance instead of replacing it.
+ * This allows multiple providers to co-exist without wiping each other's seeds.
+ *
+ * @param container - target container
+ * @param seeds - targeted seed entries apply
+ */
+function applySeeds(container, seeds) {
+  var existing = container.get(createIocContainer.SEEDS_TOKEN);
+  for (var _i = 0, seeds_1 = seeds; _i < seeds_1.length; _i++) {
+    var _a = seeds_1[_i],
+      key = _a[0],
+      state = _a[1];
+    existing.set(key, state);
+  }
+}
+
+/**
+ * Applies shared seed to the container.
+ *
+ * @param container - target container
+ * @param seed - shared seed object
+ */
+function applySharedSeed(container, seed) {
+  container.rebind(createIocContainer.SEED_TOKEN).toConstantValue(seed);
+}
+
+/**
+ * Removes specific seeds from the container.
+ * Used during provider unmounting to clean up only the entries owned by that provider.
+ *
+ * @param container - target container
+ * @param seeds - targeted seeds to remove
+ */
+function unapplySeeds(container, seeds) {
+  var existing = container.get(createIocContainer.SEEDS_TOKEN);
+  for (var _i = 0, seeds_1 = seeds; _i < seeds_1.length; _i++) {
+    var key = seeds_1[_i][0];
+    existing.delete(key);
+  }
+}
+
+/**
+ * Decorator for service methods that run after activation.
+ *
+ * @returns decorator function
+ */
+function OnActivated() {
+  return function (target, propertyKey) {
+    var constructor = target.constructor;
+    var list = createIocContainer.ACTIVATED_HANDLER_METADATA.get(constructor);
+    if (!list) {
+      list = [];
+      createIocContainer.ACTIVATED_HANDLER_METADATA.set(constructor, list);
+    }
+    list.push(propertyKey);
+  };
+}
+
+/**
+ * Decorator for service methods that run before deactivation.
+ *
+ * @returns decorator function
+ */
+function OnDeactivation() {
+  return function (target, propertyKey) {
+    var constructor = target.constructor;
+    var list = createIocContainer.DEACTIVATION_HANDLER_METADATA.get(constructor);
+    if (!list) {
+      list = [];
+      createIocContainer.DEACTIVATION_HANDLER_METADATA.set(constructor, list);
+    }
+    list.push(propertyKey);
+  };
+}
+
+Object.defineProperty(exports, "BindingType", {
+    enumerable: true,
+    get: function () { return inversify.bindingTypeValues; }
+});
+Object.defineProperty(exports, "Container", {
+    enumerable: true,
+    get: function () { return inversify.Container; }
+});
+Object.defineProperty(exports, "ContainerModule", {
+    enumerable: true,
+    get: function () { return inversify.ContainerModule; }
+});
+Object.defineProperty(exports, "Inject", {
+    enumerable: true,
+    get: function () { return inversify.inject; }
+});
+Object.defineProperty(exports, "Injectable", {
+    enumerable: true,
+    get: function () { return inversify.injectable; }
+});
+Object.defineProperty(exports, "LazyServiceIdentifier", {
+    enumerable: true,
+    get: function () { return inversify.LazyServiceIdentifier; }
+});
+Object.defineProperty(exports, "MultiInject", {
+    enumerable: true,
+    get: function () { return inversify.multiInject; }
+});
+Object.defineProperty(exports, "Named", {
+    enumerable: true,
+    get: function () { return inversify.named; }
+});
+Object.defineProperty(exports, "Optional", {
+    enumerable: true,
+    get: function () { return inversify.optional; }
+});
+Object.defineProperty(exports, "PostConstruct", {
+    enumerable: true,
+    get: function () { return inversify.postConstruct; }
+});
+Object.defineProperty(exports, "PreDestroy", {
+    enumerable: true,
+    get: function () { return inversify.preDestroy; }
+});
+Object.defineProperty(exports, "ScopeBindingType", {
+    enumerable: true,
+    get: function () { return inversify.bindingScopeValues; }
+});
+Object.defineProperty(exports, "Tagged", {
+    enumerable: true,
+    get: function () { return inversify.tagged; }
+});
+exports.CommandBus = createIocContainer.CommandBus;
+Object.defineProperty(exports, "CommandStatus", {
+    enumerable: true,
+    get: function () { return createIocContainer.ECommandStatus; }
+});
+exports.EventBus = createIocContainer.EventBus;
+exports.QueryBus = createIocContainer.QueryBus;
+exports.SEED = createIocContainer.SEED_TOKEN;
+exports.SEEDS = createIocContainer.SEEDS_TOKEN;
+exports.WireScope = createIocContainer.WireScope;
+exports.WirestateError = createIocContainer.WirestateError;
+exports.bindConstant = createIocContainer.bindConstant;
+exports.bindEntry = createIocContainer.bindEntry;
+exports.bindService = createIocContainer.bindService;
+exports.createIocContainer = createIocContainer.createIocContainer;
+exports.getEntryToken = createIocContainer.getEntryToken;
+exports.OnActivated = OnActivated;
+exports.OnCommand = OnCommand;
+exports.OnDeactivation = OnDeactivation;
+exports.OnEvent = OnEvent;
+exports.OnQuery = OnQuery;
+exports.applySeeds = applySeeds;
+exports.applySharedSeed = applySharedSeed;
+exports.command = command;
+exports.commandOptional = commandOptional;
+exports.emitEvent = emitEvent;
+exports.forwardRef = forwardRef;
+exports.query = query;
+exports.queryOptional = queryOptional;
+exports.unapplySeeds = unapplySeeds;
+//# sourceMappingURL=index.js.map

package/cjs/development/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../src/wirestate-core/alias.ts","../../../../../../../src/wirestate-core/commands/command.ts","../../../../../../../src/wirestate-core/commands/command-optional.ts","../../../../../../../src/wirestate-core/commands/on-command.ts","../../../../../../../src/wirestate-core/events/emit-event.ts","../../../../../../../src/wirestate-core/events/on-event.ts","../../../../../../../src/wirestate-core/queries/query.ts","../../../../../../../src/wirestate-core/queries/query-optional.ts","../../../../../../../src/wirestate-core/queries/on-query.ts","../../../../../../../src/wirestate-core/seeds/apply-seeds.ts","../../../../../../../src/wirestate-core/seeds/apply-shared-seed.ts","../../../../../../../src/wirestate-core/seeds/unapply-seeds.ts","../../../../../../../src/wirestate-core/service/on-activated.ts","../../../../../../../src/wirestate-core/service/on-deactivation.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":["forwardRef","forward","LazyServiceIdentifier","command","container","type","data","get","CommandBus","commandOptional","OnCommand","target","propertyKey","constructor","list","COMMAND_HANDLER_METADATA","set","push","methodName","emitEvent","payload","from","EventBus","emit","OnEvent","types","normalized","undefined","Array","isArray","__spreadArray","EVENT_HANDLER_METADATA","query","QueryBus","queryOptional","OnQuery","QUERY_HANDLER_METADATA","applySeeds","seeds","existing","SEEDS_TOKEN","_i","seeds_1","_a","key","state","applySharedSeed","seed","rebind","SEED_TOKEN","toConstantValue","unapplySeeds","delete","OnActivated","ACTIVATED_HANDLER_METADATA","OnDeactivation","DEACTIVATION_HANDLER_METADATA"],"mappings":"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"}