@portento/core 0.2.0

package/dist/index.mjs

@@ -0,0 +1,732 @@
+// src/DependencyManagement.ts
+import { container as tsyringe, Lifecycle } from "tsyringe";
+import { configure } from "mobx";
+var DependencyManagement = class _DependencyManagement {
+  constructor() {
+    // Single global container for all registrations
+    this.container = tsyringe.createChildContainer();
+    // Scope tracking maps: className -> Symbol token
+    this.rootScope = /* @__PURE__ */ new Map();
+    // Router scopes: routerSelector -> (className -> Symbol token)
+    this.routerScopes = /* @__PURE__ */ new Map();
+    // Component scopes: componentSelector -> (className -> Symbol token)
+    this.componentScopes = /* @__PURE__ */ new Map();
+    // Component-to-Router membership tracking
+    this.componentToRouter = /* @__PURE__ */ new Map();
+    // Store class references for re-registration after reset
+    this.rootClasses = /* @__PURE__ */ new Map();
+    this.routerClasses = /* @__PURE__ */ new Map();
+    this.componentClasses = /* @__PURE__ */ new Map();
+    configure({ useProxies: "always" });
+    this.container.register("DependencyManagement", {
+      useValue: this
+    });
+  }
+  static getInstance() {
+    if (!_DependencyManagement.instance) {
+      _DependencyManagement.instance = new _DependencyManagement();
+    }
+    return _DependencyManagement.instance;
+  }
+  /**
+   * Set the current resolution context (used during component instantiation)
+   */
+  setContext(selector, routerSelector) {
+    this.currentSelector = selector;
+    this.currentRouterSelector = routerSelector;
+  }
+  /**
+   * Clear the current resolution context
+   */
+  clearContext() {
+    this.currentSelector = void 0;
+    this.currentRouterSelector = void 0;
+  }
+  /**
+   * Get current component selector context
+   */
+  getCurrentSelector() {
+    return this.currentSelector;
+  }
+  /**
+   * Get current router selector context
+   */
+  getCurrentRouterSelector() {
+    return this.currentRouterSelector;
+  }
+  /**
+   * Generate a unique Symbol token for a class in a specific scope
+   */
+  getToken(className, scope) {
+    return /* @__PURE__ */ Symbol.for(`${scope}:${className}`);
+  }
+  /**
+   * Setup and register a provider in the root scope
+   */
+  setupRootContainer(Entity) {
+    const className = Entity.name;
+    if (!this.rootScope.has(className)) {
+      const scopedToken = this.getToken(className, "root");
+      this.rootScope.set(className, scopedToken);
+      this.rootClasses.set(className, Entity);
+      if (!this.container.isRegistered(scopedToken)) {
+        this.container.register(
+          scopedToken,
+          { useClass: Entity },
+          { lifecycle: Lifecycle.Singleton }
+        );
+      }
+    }
+  }
+  /**
+   * Get the root container (for backward compatibility)
+   */
+  getRootContainer() {
+    return this.container;
+  }
+  /**
+   * Legacy property accessor for backward compatibility
+   */
+  get root() {
+    return this.container;
+  }
+  /**
+   * Setup and register providers in a component scope
+   */
+  setupComponentContainer(selector, Providers = []) {
+    if (!this.componentScopes.has(selector)) {
+      this.componentScopes.set(selector, /* @__PURE__ */ new Map());
+      this.componentClasses.set(selector, /* @__PURE__ */ new Map());
+    }
+    const scopeMap = this.componentScopes.get(selector);
+    const classMap = this.componentClasses.get(selector);
+    if (!scopeMap || !classMap) {
+      throw new Error(
+        `Failed to create component scope for selector: ${selector}`
+      );
+    }
+    for (const Provider of Providers) {
+      const className = Provider.name;
+      if (!scopeMap.has(className)) {
+        const scopedToken = this.getToken(
+          className,
+          `component:${selector}`
+        );
+        scopeMap.set(className, scopedToken);
+        classMap.set(className, Provider);
+        if (!this.container.isRegistered(scopedToken)) {
+          this.container.register(
+            scopedToken,
+            { useClass: Provider },
+            { lifecycle: Lifecycle.Singleton }
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Get a component-level container by selector (backward compatibility)
+   */
+  getComponentContainer(selector) {
+    if (!this.componentScopes.has(selector)) {
+      return void 0;
+    }
+    return this.container;
+  }
+  /**
+   * Legacy property accessor for backward compatibility
+   */
+  get component() {
+    const legacyMap = /* @__PURE__ */ new Map();
+    for (const selector of this.componentScopes.keys()) {
+      legacyMap.set(selector, this.container);
+    }
+    return legacyMap;
+  }
+  /**
+   * Setup and register providers in a router scope, tracking component membership
+   */
+  setupRouterContainer(Components, Providers, selector) {
+    if (!this.routerScopes.has(selector)) {
+      this.routerScopes.set(selector, /* @__PURE__ */ new Map());
+      this.routerClasses.set(selector, /* @__PURE__ */ new Map());
+    }
+    const scopeMap = this.routerScopes.get(selector);
+    const classMap = this.routerClasses.get(selector);
+    if (!scopeMap || !classMap) {
+      throw new Error(
+        `Failed to create router scope for selector: ${selector}`
+      );
+    }
+    for (const Component2 of Components) {
+      const componentName = typeof Component2 === "string" ? Component2 : Component2.name;
+      this.componentToRouter.set(componentName, selector);
+    }
+    for (const Provider of Providers) {
+      const className = Provider.name;
+      if (!scopeMap.has(className)) {
+        const scopedToken = this.getToken(
+          className,
+          `router:${selector}`
+        );
+        scopeMap.set(className, scopedToken);
+        classMap.set(className, Provider);
+        if (!this.container.isRegistered(scopedToken)) {
+          this.container.register(
+            scopedToken,
+            { useClass: Provider },
+            { lifecycle: Lifecycle.Singleton }
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Get the router selector for a component (if registered in a router)
+   */
+  getRouterForComponent(componentName) {
+    return this.componentToRouter.get(componentName);
+  }
+  /**
+   * Fetch a provider from the router container associated with an entity (backward compatibility)
+   */
+  fetchFromRouterContainer(Entity) {
+    const routerSelector = this.getRouterForComponent(
+      Entity.name
+    );
+    if (routerSelector && this.routerScopes.has(routerSelector)) {
+      return this.container;
+    }
+    return void 0;
+  }
+  /**
+   * Get a router-level container by selector (backward compatibility)
+   */
+  getRouterContainer(selector) {
+    if (!this.routerScopes.has(selector)) {
+      return void 0;
+    }
+    return this.container;
+  }
+  /**
+   * Legacy property accessor for backward compatibility
+   */
+  get router() {
+    const legacyMap = /* @__PURE__ */ new Map();
+    for (const selector of this.routerScopes.keys()) {
+      legacyMap.set(selector, this.container);
+    }
+    return legacyMap;
+  }
+  /**
+   * Check if a class is a MobX store by looking for MobX symbols
+   */
+  isMobxStore(instance) {
+    const mobxSymbol = "mobx-stored-annotations";
+    const symbols = Object.getOwnPropertySymbols(instance);
+    return symbols.some((s) => s.description === mobxSymbol);
+  }
+  /**
+   * Resolve a dependency with strict scope isolation:
+   * 1. Component scope (if component explicitly registered the provider)
+   * 2. Router scope (ONLY if component is part of that router's components array)
+   * 3. Root scope (for @Injectable({ providedIn: 'root' }) services)
+   *
+   * Scope override behavior:
+   * - If a root service is re-registered at router/component level, that scope gets a NEW instance
+   * - Router-scoped services are ONLY accessible to components within that router
+   * - Parent components cannot access child router services
+   *
+   * Returns undefined if no provider is found in accessible scopes
+   */
+  resolve(className, componentSelector, routerSelector, componentClassName) {
+    if (className === "DependencyManagement") {
+      return this.container.resolve("DependencyManagement");
+    }
+    if (componentSelector) {
+      const componentScope = this.componentScopes.get(componentSelector);
+      const componentToken = componentScope?.get(className);
+      if (componentToken && this.container.isRegistered(componentToken)) {
+        return this.container.resolve(componentToken);
+      }
+    }
+    if (routerSelector) {
+      const routerScope = this.routerScopes.get(routerSelector);
+      const routerToken = routerScope?.get(className);
+      if (routerToken && this.container.isRegistered(routerToken)) {
+        return this.container.resolve(routerToken);
+      }
+    }
+    const parentRouterSelector = componentClassName ? this.getRouterForComponent(componentClassName) : void 0;
+    if (parentRouterSelector && parentRouterSelector !== routerSelector) {
+      const parentRouterScope = this.routerScopes.get(parentRouterSelector);
+      const parentRouterToken = parentRouterScope?.get(className);
+      if (parentRouterToken && this.container.isRegistered(parentRouterToken)) {
+        return this.container.resolve(parentRouterToken);
+      }
+    }
+    const rootToken = this.rootScope.get(className);
+    if (rootToken && this.container.isRegistered(rootToken)) {
+      return this.container.resolve(rootToken);
+    }
+    return void 0;
+  }
+  /**
+   * Convenience method for resolving dependencies using current context.
+   * Use this in component constructors when DependencyManagement is injected.
+   *
+   * @example
+   * constructor(private dm: DependencyManagement) {
+   *   this.myService = dm.get<MyService>('MyService');
+   * }
+   */
+  get(className) {
+    return this.resolve(
+      className,
+      this.currentSelector,
+      this.currentRouterSelector
+    );
+  }
+  /**
+   * Resolve a dependency from component, router, or root scope (backward compatibility)
+   */
+  resolveFromScopes(EntityName, componentContainer, routerContainer) {
+    let componentSelector;
+    let routerSelector;
+    if (componentContainer) {
+      for (const [selector, _scopeMap] of this.componentScopes.entries()) {
+        componentSelector = selector;
+        break;
+      }
+    }
+    if (routerContainer) {
+      for (const [selector, _scopeMap] of this.routerScopes.entries()) {
+        routerSelector = selector;
+        break;
+      }
+    }
+    return this.resolve(EntityName, componentSelector, routerSelector);
+  }
+  /**
+   * Re-register all providers (helper for reset operations)
+   */
+  reregisterAll() {
+    for (const [className, token] of this.rootScope.entries()) {
+      const Provider = this.rootClasses.get(className);
+      if (Provider) {
+        this.container.register(
+          token,
+          { useClass: Provider },
+          { lifecycle: Lifecycle.Singleton }
+        );
+      }
+    }
+    for (const [selector, routerScope] of this.routerScopes.entries()) {
+      const routerClassMap = this.routerClasses.get(selector);
+      if (routerClassMap) {
+        for (const [className, token] of routerScope.entries()) {
+          const Provider = routerClassMap.get(className);
+          if (Provider) {
+            this.container.register(
+              token,
+              { useClass: Provider },
+              { lifecycle: Lifecycle.Singleton }
+            );
+          }
+        }
+      }
+    }
+    for (const [selector, componentScope] of this.componentScopes.entries()) {
+      const componentClassMap = this.componentClasses.get(selector);
+      if (componentClassMap) {
+        for (const [className, token] of componentScope.entries()) {
+          const Provider = componentClassMap.get(className);
+          if (Provider) {
+            this.container.register(
+              token,
+              { useClass: Provider },
+              { lifecycle: Lifecycle.Singleton }
+            );
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Reset all instances in a specific scope
+   * Creates fresh container and re-registers all providers
+   * Note: Due to tsyringe limitations, this resets ALL scopes but is still useful for cleanup
+   */
+  resetScope(_scope, _selector) {
+    this.container.reset();
+    this.container = tsyringe.createChildContainer();
+    this.reregisterAll();
+  }
+  /**
+   * Reset a specific class across all scopes
+   * Creates fresh container and re-registers all providers
+   * Note: Due to tsyringe limitations, this resets ALL instances
+   */
+  resetClass(_className) {
+    this.container.reset();
+    this.container = tsyringe.createChildContainer();
+    this.reregisterAll();
+  }
+  /**
+   * Reset all instances in all scopes
+   * This clears all cached singletons but keeps registrations
+   */
+  resetAll() {
+    this.container.clearInstances();
+  }
+};
+
+// src/decorators/Component.ts
+import React from "react";
+import { observer } from "mobx-react";
+import { injectable } from "tsyringe";
+var componentRegistry = /* @__PURE__ */ new Map();
+var componentReverseRegistry = /* @__PURE__ */ new Map();
+function Component(params) {
+  const decorator = function(Entity) {
+    injectable()(Entity);
+    class ComponentWrapper extends React.Component {
+      constructor(props) {
+        super(props);
+        this.entityInstance = null;
+        const initialState = {};
+        this.state = initialState;
+        this.dependencyManagement = DependencyManagement.getInstance();
+        this.dependencyManagement.setupComponentContainer(params.selector, [
+          ...params.providers || [],
+          Entity
+        ]);
+        const componentContainer = this.dependencyManagement.getComponentContainer(params.selector);
+        const routerSelector = this.dependencyManagement.getRouterForComponent(Entity.name);
+        const self = this;
+        const controller = {
+          props,
+          get state() {
+            return self.state;
+          },
+          setState: (state) => {
+            if (typeof state === "function") {
+              this.setState((prevState) => {
+                const newState = state(prevState);
+                return newState;
+              });
+            } else {
+              this.setState((prevState) => {
+                const newState = {
+                  ...prevState,
+                  ...state
+                };
+                return newState;
+              });
+            }
+          },
+          forceUpdate: this.forceUpdate.bind(this)
+        };
+        componentContainer?.register("Controller", { useValue: controller });
+        const paramTypes = Reflect.getMetadata(
+          "design:paramtypes",
+          Entity
+        );
+        const constructorArgs = [];
+        if (paramTypes && paramTypes.length > 0) {
+          for (const ParamType of paramTypes) {
+            let dependency = this.dependencyManagement.resolve(
+              ParamType.name,
+              params.selector,
+              routerSelector,
+              Entity.name
+            );
+            if (dependency === void 0 && ParamType.name === "Object") {
+              dependency = componentContainer?.resolve("Controller");
+            }
+            constructorArgs.push(dependency);
+          }
+        }
+        this.entityInstance = // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        new Entity(...constructorArgs) ?? null;
+        if (this.entityInstance?.state !== void 0 && this.entityInstance?.state !== null) {
+          const entityState = Object.assign(
+            {},
+            this.entityInstance.state
+          );
+          Object.assign(this.state, entityState);
+        }
+        if (this.entityInstance) {
+          const prototype = Object.getPrototypeOf(
+            this.entityInstance
+          );
+          Object.getOwnPropertyNames(prototype).forEach((key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+            if (key !== "constructor" && descriptor && typeof descriptor.value === "function") {
+              this.entityInstance[key] = descriptor.value.bind(this.entityInstance);
+            }
+          });
+          if ("state" in this.entityInstance) {
+            Object.defineProperty(this.entityInstance, "state", {
+              get: () => controller.state,
+              configurable: true,
+              enumerable: true
+            });
+          }
+        }
+      }
+      componentDidMount() {
+        if (this.entityInstance && typeof this.entityInstance.componentDidMount === "function") {
+          this.entityInstance.componentDidMount.call(this.entityInstance);
+        }
+      }
+      componentDidUpdate(prevProps, prevState) {
+        if (this.entityInstance && typeof this.entityInstance.componentDidUpdate === "function") {
+          this.entityInstance.componentDidUpdate.call(
+            this.entityInstance,
+            prevProps,
+            prevState
+          );
+        }
+      }
+      componentWillUnmount() {
+        if (this.entityInstance && typeof this.entityInstance.componentWillUnmount === "function") {
+          this.entityInstance.componentWillUnmount.call(this.entityInstance);
+        }
+      }
+      render() {
+        if (!this.entityInstance) {
+          return null;
+        }
+        return this.entityInstance.render.call(this.entityInstance);
+      }
+    }
+    const wrappedComponent = observer(ComponentWrapper);
+    const reactComponent = wrappedComponent;
+    componentRegistry.set(Entity.name, reactComponent);
+    componentReverseRegistry.set(reactComponent, Entity.name);
+    return Entity;
+  };
+  decorator.$provider = (Entity) => {
+    const component = componentRegistry.get(Entity.name);
+    if (!component) {
+      throw new Error(
+        `Component ${Entity.name} not found. Make sure to apply @Component decorator first.`
+      );
+    }
+    return component;
+  };
+  return decorator;
+}
+function getComponentClassName(component) {
+  return componentReverseRegistry.get(component);
+}
+Component.$provider = (Entity) => {
+  const component = componentRegistry.get(Entity.name);
+  if (!component) {
+    throw new Error(
+      `Component ${Entity.name} not found. Make sure to apply @Component decorator first.`
+    );
+  }
+  return component;
+};
+
+// src/decorators/Injectable.ts
+import { injectable as injectable2 } from "tsyringe";
+function Injectable(params) {
+  return function(Entity) {
+    injectable2()(Entity);
+    if (params?.providedIn === "root") {
+      const dependencyManagement = DependencyManagement.getInstance();
+      dependencyManagement.setupRootContainer(Entity);
+    }
+    return Entity;
+  };
+}
+
+// src/decorators/Router.ts
+import React2 from "react";
+import { observer as observer2 } from "mobx-react";
+import { injectable as injectable3 } from "tsyringe";
+var routerRegistry = /* @__PURE__ */ new Map();
+var routerReverseRegistry = /* @__PURE__ */ new Map();
+function getRouterClassName(router) {
+  return routerReverseRegistry.get(router);
+}
+function Router(params) {
+  const decorator = function(Entity) {
+    injectable3()(Entity);
+    const dependencyManagement = DependencyManagement.getInstance();
+    const componentClassNames = params.components.map((comp) => {
+      const componentClassName = getComponentClassName(
+        comp
+      );
+      if (componentClassName) {
+        return componentClassName;
+      }
+      const routerClassName = getRouterClassName(
+        comp
+      );
+      if (routerClassName) {
+        return routerClassName;
+      }
+      const classComp = comp;
+      return classComp.name || void 0;
+    }).filter((name) => name !== void 0);
+    dependencyManagement.setupRouterContainer(
+      componentClassNames,
+      [...params.providers || [], Entity],
+      params.selector
+    );
+    class RouterWrapper extends React2.Component {
+      constructor(props) {
+        super(props);
+        this.entityInstance = null;
+        const initialState = {};
+        this.state = initialState;
+        this.dependencyManagement = DependencyManagement.getInstance();
+        const routerContainerInstance = this.dependencyManagement.getRouterContainer(params.selector);
+        const wrapperInstance = this;
+        const controller = {
+          props,
+          get state() {
+            return wrapperInstance.state;
+          },
+          setState: (state) => {
+            if (typeof state === "function") {
+              this.setState((prevState) => {
+                const newState = state(prevState);
+                if (this.entityInstance?.state) {
+                  Object.assign(this.entityInstance.state, newState);
+                }
+                return newState;
+              });
+            } else {
+              this.setState((prevState) => {
+                const newState = {
+                  ...prevState,
+                  ...state
+                };
+                if (this.entityInstance?.state) {
+                  Object.assign(this.entityInstance.state, newState);
+                }
+                return newState;
+              });
+            }
+          },
+          forceUpdate: this.forceUpdate.bind(this)
+        };
+        routerContainerInstance?.register("Controller", { useValue: controller });
+        const paramTypes = Reflect.getMetadata(
+          "design:paramtypes",
+          Entity
+        );
+        const constructorArgs = [];
+        if (paramTypes && paramTypes.length > 0) {
+          for (const ParamType of paramTypes) {
+            let dependency = this.dependencyManagement.resolve(
+              ParamType.name,
+              void 0,
+              // No component selector - this is a router
+              params.selector,
+              // Own router scope
+              Entity.name
+              // Pass class name to find parent router if needed
+            );
+            if (dependency === void 0 && ParamType.name === "Object") {
+              dependency = routerContainerInstance?.resolve("Controller");
+            }
+            constructorArgs.push(dependency);
+          }
+        }
+        this.entityInstance = // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        new Entity(...constructorArgs) ?? null;
+        if (this.entityInstance?.state !== void 0 && this.entityInstance?.state !== null) {
+          const entityState = Object.assign(
+            {},
+            this.entityInstance.state
+          );
+          Object.assign(this.state, entityState);
+        }
+        if (this.entityInstance) {
+          const prototype = Object.getPrototypeOf(
+            this.entityInstance
+          );
+          Object.getOwnPropertyNames(prototype).forEach((key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+            if (key !== "constructor" && descriptor && typeof descriptor.value === "function") {
+              this.entityInstance[key] = descriptor.value.bind(this.entityInstance);
+            }
+          });
+          if ("state" in this.entityInstance) {
+            Object.defineProperty(this.entityInstance, "state", {
+              get: () => controller.state,
+              configurable: true,
+              enumerable: true
+            });
+          }
+        }
+      }
+      componentDidMount() {
+        if (this.entityInstance && typeof this.entityInstance.componentDidMount === "function") {
+          this.entityInstance.componentDidMount.call(this.entityInstance);
+        }
+      }
+      componentDidUpdate(prevProps, prevState) {
+        if (this.entityInstance && typeof this.entityInstance.componentDidUpdate === "function") {
+          this.entityInstance.componentDidUpdate.call(
+            this.entityInstance,
+            prevProps,
+            prevState
+          );
+        }
+      }
+      componentWillUnmount() {
+        if (this.entityInstance && typeof this.entityInstance.componentWillUnmount === "function") {
+          this.entityInstance.componentWillUnmount.call(this.entityInstance);
+        }
+      }
+      render() {
+        if (!this.entityInstance) {
+          return null;
+        }
+        return this.entityInstance.render.call(this.entityInstance);
+      }
+    }
+    const wrappedComponent = observer2(RouterWrapper);
+    const reactComponent = wrappedComponent;
+    routerRegistry.set(Entity.name, reactComponent);
+    routerReverseRegistry.set(reactComponent, Entity.name);
+    return Entity;
+  };
+  return decorator;
+}
+Router.$provider = (Entity) => {
+  const component = routerRegistry.get(Entity.name);
+  if (!component) {
+    throw new Error(
+      `Router ${Entity.name} not found. Make sure to apply @Router decorator first.`
+    );
+  }
+  return component;
+};
+
+// src/index.ts
+function resetScope(_scope, _selector) {
+  DependencyManagement.getInstance().resetScope(_scope, _selector);
+}
+function resetClass(_className) {
+  DependencyManagement.getInstance().resetClass(_className);
+}
+function resetAll() {
+  DependencyManagement.getInstance().resetAll();
+}
+export {
+  Component,
+  Injectable,
+  Router,
+  resetAll,
+  resetClass,
+  resetScope
+};
+//# sourceMappingURL=index.mjs.map