@raubjo/architect-core 0.1.1 → 0.1.2

package/README.md

@@ -12,14 +12,19 @@ You keep inversion of control, lifecycle hooks, and runtime reactivity.
 - Predictable lifecycle (`register` then `boot`)
 - Framework runtime helpers (`react`, `solid`, `svelte`, `vue`)
 - Config repository and facades
-- Automatic config loading from your project `config` files
 
 If you are familiar with Laravel service providers and container bindings, this should feel familiar.
 
 ## Install
 
 ```bash
-bun add @raubjo/architect-core inversify reflect-metadata
+bun add @raubjo/architect-core
+```
+
+If you want the Inversify adapter:
+
+```bash
+bun add inversify reflect-metadata
 ```
 
 For framework-specific runtime helpers, import from subpaths like `@raubjo/architect-core/react`.
@@ -27,10 +32,13 @@ For framework-specific runtime helpers, import from subpaths like `@raubjo/archi
 ## Quick start
 
 ```ts
-import "reflect-metadata";
 import { Application } from "@raubjo/architect-core";
 
-const { container, stop } = Application.configure("./")
+const { container, stop } = Application.configure({
+  config: {
+    app: { name: "IOC Application" },
+  },
+})
   .withProviders([])
   .run();
 
@@ -41,6 +49,75 @@ const config = container.get("config");
 stop();
 ```
 
+## Container adapters
+
+`Application` supports three container adapter modes:
+
+- `builtin`: always use the built-in container implementation.
+- `inversify`: require and use the registered Inversify adapter.
+- `auto`: use Inversify when available, otherwise fallback to `builtin`.
+
+### Builtin container
+
+Builtin is the default/fallback container and supports:
+
+- Constructor injection via `design:paramtypes` metadata
+- `@inject(...)` parameter token overrides
+- `singleton`, `transient`, and `instance` registration
+- Fluent `bind(...).to(...)/toDynamicValue(...)/toConstantValue(...)`
+
+```ts
+import "reflect-metadata";
+import { Application, injectDependency } from "@raubjo/architect-core";
+
+class Logger {}
+
+class Service {
+  constructor(
+    public readonly logger: Logger,
+    @injectDependency("config.appName") public readonly appName: string,
+  ) {}
+}
+
+const { container } = Application.configure({
+  container: { adapter: "builtin" },
+  config: {
+    appName: "IOC Application",
+  },
+})
+  .withServices(({ container }) => {
+    container.singleton(Logger, Logger);
+    container.transient(Service, Service);
+    container.instance("config.appName", "IOC Application");
+  })
+  .run();
+
+const service = container.make(Service);
+```
+
+### Inversify container
+
+To use Inversify, install `inversify` and `reflect-metadata`, then register a factory on `globalThis.__iocContainerFactoryRegistry`.
+
+```ts
+import "reflect-metadata";
+import { Application } from "@raubjo/architect-core";
+import InversifyContainer from "@raubjo/architect-core/container/adapters/inversify";
+
+globalThis.__iocContainerFactoryRegistry = {
+  inversify: () => new InversifyContainer(),
+};
+
+const running = Application.configure({
+  container: { adapter: "inversify" },
+  config: {
+    app: { name: "IOC Application" },
+  },
+}).run();
+```
+
+You can also keep `adapter: "auto"` and let runtime detection pick Inversify when `package.json` includes it.
+
 ## Service provider example
 
 Use providers to define business rules and service construction once.
@@ -86,7 +163,7 @@ class PricingServiceProvider extends ServiceProvider {
 ```ts
 import "reflect-metadata";
 import { Application } from "@raubjo/architect-core";
-import { ReactRenderer, useService } from "@raubjo/architect-core/react";
+import { Renderer as ReactRenderer, useService } from "@raubjo/architect-core/react";
 import PricingServiceProvider from "./providers/pricing-service-provider";
 
 function QuotePanel() {
@@ -109,39 +186,16 @@ const app = Application.configure("./")
 app.run();
 ```
 
-## Config auto-loading from `basePath/config`
+## Config
 
-`Application.configure(basePath)` controls where config files are discovered.
-
-When `run()` is called, config is assembled from:
-
-1. Built-in default `app` config.
-2. Any default exports found in:
-   - `${basePath}/config/*.{js,mjs,cjs,ts,mts,cts}`
-   - `${basePath}/src/config/*.{js,mjs,cjs,ts,mts,cts}`
-
-Each file becomes a top-level config key based on the filename:
-
-- `config/cache.ts` -> `config.get("cache")`
-- `src/config/pricing.ts` -> `config.get("pricing")`
-
-Example:
+`Application` uses config passed directly to `configure`:
 
 ```ts
-// ./config/pricing.ts
-export default {
-  taxRate: 0.0825,
-  currency: "USD",
-};
-```
-
-```ts
-const app = Application.configure("./").run();
-const config = app.container.get("config") as {
-  get: <T = unknown>(key: string, defaultValue?: T) => T;
-};
-
-config.get("pricing.taxRate"); // 0.0825
+const app = Application.configure({
+  config: {
+    pricing: { taxRate: 0.0825, currency: "USD" },
+  },
+}).run();
 ```
 
 ## Lifecycle order
@@ -159,4 +213,4 @@ Cleanup runs in reverse order when `stop()` is called.
 ## Notes
 
 - `Application.make(...)` is available after `run()` and resolves from the active container.
-- Config source files are cached by `basePath`; use `Application.clearConfigCache()` in tests when needed.
+- `Application.configure(basePath)` is still supported for compatibility, but config values should be passed via `configure({ config })`.

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@raubjo/architect-core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": false,
+  "license": "MIT",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/renderers/adapters/svelte.ts

@@ -1,3 +1,4 @@
+import { mount, unmount } from "svelte";
 import type { Cleanup } from "../../support/service-provider";
 import type Contract from "../contract";
 import type { RendererContext } from "../contract";
@@ -12,6 +13,12 @@ type SvelteComponentConstructor = new (options: {
     props?: Record<string, unknown>;
 }) => SvelteComponentInstance;
 
+type SvelteMount = (
+    component: unknown,
+    options: { target: Element; props?: Record<string, unknown> },
+) => unknown;
+type SvelteUnmount = (instance: unknown) => void | Promise<void>;
+
 export default class SvelteRenderer implements Contract {
     constructor() {}
 
@@ -25,11 +32,30 @@ export default class SvelteRenderer implements Contract {
             throw new Error(`Missing mount node #${rootElementId}.`);
         }
 
+        const props = { container };
+        const svelteMount = mount as unknown as SvelteMount | undefined;
+        const svelteUnmount = unmount as unknown as SvelteUnmount | undefined;
+
+        if (
+            typeof svelteMount === "function" &&
+            typeof svelteUnmount === "function"
+        ) {
+            try {
+                const instance = svelteMount(RootComponent, {
+                    target: mountNode,
+                    props,
+                });
+
+                return () => {
+                    void svelteUnmount(instance);
+                };
+            } catch (_error) {
+                // Fallback to the legacy component constructor API.
+            }
+        }
+
         const Component = RootComponent as SvelteComponentConstructor;
-        const instance = new Component({
-            target: mountNode,
-            props: { container },
-        });
+        const instance = new Component({ target: mountNode, props });
 
         return () => {
             if (typeof instance.$destroy === "function") {