@abdokouta/react-support 1.1.0 → 1.2.0

package/dist/index.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,23 +27,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   BaseRegistry: () => BaseRegistry,
   Collection: () => Collection,
-  Facade: () => Facade,
   MapCollection: () => MapCollection,
+  MultipleInstanceManager: () => MultipleInstanceManager,
   SetCollection: () => SetCollection,
   Str: () => Str,
   collect: () => collect,
   collectMap: () => collectMap,
-  collectSet: () => collectSet,
-  createFacade: () => createFacade,
-  createFacadeClass: () => createFacadeClass,
-  getContainerFromModule: () => getContainerFromModule,
-  isFake: () => isFake
+  collectSet: () => collectSet
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -68,7 +66,23 @@ var Str = class _Str {
    * Convert a string to title case following APA guidelines
    */
   static apa(value) {
-    const minorWords = ["a", "an", "and", "as", "at", "but", "by", "for", "in", "of", "on", "or", "the", "to", "up"];
+    const minorWords = [
+      "a",
+      "an",
+      "and",
+      "as",
+      "at",
+      "but",
+      "by",
+      "for",
+      "in",
+      "of",
+      "on",
+      "or",
+      "the",
+      "to",
+      "up"
+    ];
     const words = value.split(" ");
     return words.map((word, index) => {
       if (index === 0 || !minorWords.includes(word.toLowerCase())) {
@@ -676,6 +690,7 @@ var Str = class _Str {
 var import_collect = __toESM(require("collect.js"), 1);
 var Collection = class _Collection {
   constructor(items = []) {
+    __publicField(this, "collection");
     this.collection = (0, import_collect.default)(items);
   }
   /**
@@ -828,7 +843,10 @@ var Collection = class _Collection {
    * Join all items from the collection using a string
    */
   join(glue, finalGlue) {
-    return this.collection.join(glue, finalGlue);
+    if (finalGlue) {
+      return this.collection.join(glue, finalGlue);
+    }
+    return this.collection.join(glue);
   }
   /**
    * Key the collection by the given key
@@ -1087,6 +1105,7 @@ function collect(items = []) {
 // src/collections/map.collection.ts
 var MapCollection = class _MapCollection {
   constructor(entries) {
+    __publicField(this, "internalMap");
     if (entries && typeof entries === "object" && !(Symbol.iterator in entries)) {
       this.internalMap = new Map(Object.entries(entries));
     } else {
@@ -1386,6 +1405,7 @@ function collectMap(entries) {
 // src/collections/set.collection.ts
 var SetCollection = class _SetCollection {
   constructor(items) {
+    __publicField(this, "set");
     this.set = new Set(items);
   }
   /**
@@ -1703,716 +1723,285 @@ function collectSet(items) {
 }
 
 // src/registry/base-registry.ts
-var RegistryCollection = class {
-  constructor() {
-    this._storage = new MapCollection();
-  }
-  add(key, value) {
-    this._storage.set(key, value);
-  }
-  get(key) {
-    return this._storage.get(key);
-  }
-  getAll() {
-    return this._storage.values();
-  }
-  getKeys() {
-    return this._storage.keys();
-  }
-  getAsRecord() {
-    return this._storage.toObject();
-  }
-  has(key) {
-    return this._storage.has(key);
-  }
-  remove(key) {
-    return this._storage.delete(key);
-  }
-  clear() {
-    this._storage.clear();
-  }
-  size() {
-    return this._storage.size();
-  }
-  isEmpty() {
-    return this._storage.isEmpty();
-  }
-  forEach(callback) {
-    this._storage.each((value, key) => {
-      callback(value, key);
-    });
-  }
-  map(callback) {
-    const result = [];
-    this._storage.each((value, key) => {
-      result.push(callback(value, key));
-    });
-    return result;
-  }
-  filter(predicate) {
-    const result = [];
-    this._storage.each((value, key) => {
-      if (predicate(value, key)) {
-        result.push(value);
-      }
-    });
-    return result;
-  }
-  find(predicate) {
-    return this._storage.first(predicate);
-  }
-};
 var BaseRegistry = class {
   /**
-   * Creates a new BaseRegistry instance
-   * 
-   * Initializes the registry with optional configuration for default
-   * item and validation hooks. By default, uses MapCollection for storage.
-   * 
-   * @param options - Registry configuration options
-   * 
-   * @example
-   * ```typescript
-   * // Simple registry without options
-   * const registry = new BaseRegistry<Theme>();
-   * ```
-   * 
-   * @example
-   * ```typescript
-   * // Registry with default item
-   * const registry = new BaseRegistry<Theme>({
-   *   defaultItem: defaultTheme
-   * });
-   * ```
-   * 
-   * @example
-   * ```typescript
-   * // Registry with validation
-   * const registry = new BaseRegistry<Theme>({
-   *   validateBeforeAdd: (key, theme) => {
-   *     if (!theme.name) {
-   *       return { valid: false, error: 'Theme must have a name' };
-   *     }
-   *     return { valid: true };
-   *   },
-   *   afterAdd: (key, theme) => {
-   *     console.log(`Registered theme: ${theme.name}`);
-   *   }
-   * });
-   * ```
+   * Create a new registry.
+   *
+   * @param options - Optional default item, validation, and lifecycle hooks
    */
   constructor(options = {}) {
-    this.collection = new RegistryCollection();
+    /**
+     * Internal map-based storage.
+     */
+    __publicField(this, "storage", new MapCollection());
+    /**
+     * Fallback value returned by {@link get} when a key is missing.
+     */
+    __publicField(this, "defaultItem");
+    /**
+     * Optional validation executed before every {@link register} call.
+     */
+    __publicField(this, "validateBeforeAdd");
+    /**
+     * Optional callback executed after a successful {@link register}.
+     */
+    __publicField(this, "afterAdd");
     this.defaultItem = options.defaultItem;
     this.validateBeforeAdd = options.validateBeforeAdd;
     this.afterAdd = options.afterAdd;
   }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Core
+  // ──────────────────────────────────────────────────────────────────────────
   /**
-   * Register an item in the registry
-   * 
-   * Adds or updates an item in the registry with the specified key.
-   * If an item with the same key already exists, it will be replaced.
-   * 
-   * If a validation hook is configured, it will be called before adding
-   * the item. If validation fails, an error is thrown and the item is
-   * not added.
-   * 
-   * If an afterAdd hook is configured, it will be called after the item
-   * is successfully added.
-   * 
-   * Time Complexity: O(1) + validation time
-   * 
-   * @param key - Unique identifier for the item
-   * @param item - Item to register
+   * Register (add or replace) an item.
+   *
+   * Runs the `validateBeforeAdd` hook first; throws on failure.
+   * Fires the `afterAdd` hook on success.
+   *
+   * @param key  - Unique identifier
+   * @param item - Value to store
    * @throws Error if validation fails
-   * 
-   * @example
-   * ```typescript
-   * const registry = new BaseRegistry<Theme>();
-   * 
-   * // Register a theme
-   * registry.register('blue', {
-   *   name: 'Blue',
-   *   colors: { accent: '#0000FF' }
-   * });
-   * 
-   * // Update existing theme
-   * registry.register('blue', {
-   *   name: 'Blue',
-   *   colors: { accent: '#0066FF' }
-   * });
-   * ```
    */
   register(key, item) {
     if (this.validateBeforeAdd) {
       const result = this.validateBeforeAdd(key, item);
       if (!result.valid) {
-        throw new Error(
-          `Validation failed for key "${key}": ${result.error || "Unknown error"}`
-        );
+        throw new Error(`Validation failed for key "${key}": ${result.error || "Unknown error"}`);
       }
     }
-    this.collection.add(key, item);
+    this.storage.set(key, item);
     if (this.afterAdd) {
       this.afterAdd(key, item);
     }
   }
-  // ============================================================================
-  // Collection Interface Implementation
-  // All methods below delegate directly to the internal collection
-  // ============================================================================
-  /**
-   * Add an item to the collection (alias for register)
-   * 
-   * This method is part of the Collection interface.
-   * It delegates to register() to ensure validation hooks are called.
-   * 
-   * Time Complexity: O(1) + validation time
-   * 
-   * @param key - Unique identifier for the item
-   * @param value - Item to add
+  // ──────────────────────────────────────────────────────────────────────────
+  // Collection interface
+  // ──────────────────────────────────────────────────────────────────────────
+  /**
+   * @inheritdoc — delegates to {@link register} so hooks still fire.
    */
   add(key, value) {
     this.register(key, value);
   }
   /**
-   * Get an item from the registry
-   * 
-   * Retrieves an item by its key. If the item doesn't exist:
-   * - Returns the default item if one was configured
-   * - Returns undefined if no default item was configured
-   * 
-   * Time Complexity: O(1)
-   * 
+   * Retrieve an item by key.
+   *
+   * Falls back to {@link defaultItem} when the key is not found.
+   *
    * @param key - Item identifier
-   * @returns Item if found, default item if configured, or undefined
-   * 
-   * @example
-   * ```typescript
-   * const theme = registry.get('blue');
-   * ```
+   * @returns The stored value, the default item, or `undefined`
    */
   get(key) {
-    const item = this.collection.get(key);
-    if (item !== void 0) {
-      return item;
-    }
-    return this.defaultItem;
-  }
-  /**
-   * Get all items in the registry
-   * 
-   * Returns an array containing all items in the registry.
-   * The order of items depends on the collection implementation
-   * (MapCollection maintains insertion order).
-   * 
-   * Time Complexity: O(n) where n is the number of items
-   * 
-   * @returns Array of all items in the registry
-   * 
-   * @example
-   * ```typescript
-   * const allThemes = registry.getAll();
-   * ```
+    return this.storage.get(key) ?? this.defaultItem;
+  }
+  /**
+   * Return every stored value in insertion order.
    */
   getAll() {
-    return this.collection.getAll();
-  }
-  /**
-   * Get all keys in the registry
-   * 
-   * Returns an array containing all keys in the registry.
-   * Useful for iteration or checking what items are registered.
-   * 
-   * Time Complexity: O(n) where n is the number of items
-   * 
-   * @returns Array of all keys in the registry
-   * 
-   * @example
-   * ```typescript
-   * const keys = registry.getKeys();
-   * ```
+    return this.storage.values();
+  }
+  /**
+   * Return every registered key in insertion order.
    */
   getKeys() {
-    return this.collection.getKeys();
-  }
-  /**
-   * Get registry as a record object
-   * 
-   * Converts the registry to a plain JavaScript object (record)
-   * with keys mapping to values. Useful for serialization.
-   * 
-   * Time Complexity: O(n) where n is the number of items
-   * 
-   * @returns Record object with keys mapping to values
-   * 
-   * @example
-   * ```typescript
-   * const record = registry.getAsRecord();
-   * ```
+    return this.storage.keys();
+  }
+  /**
+   * Convert the registry to a plain `Record<string, T>`.
    */
   getAsRecord() {
-    return this.collection.getAsRecord();
-  }
-  /**
-   * Check if an item is registered
-   * 
-   * Checks whether an item with the specified key exists in the registry.
-   * Does not check the value, only the presence of the key.
-   * 
-   * Time Complexity: O(1)
-   * 
-   * @param key - Item identifier to check
-   * @returns True if item is registered, false otherwise
-   * 
-   * @example
-   * ```typescript
-   * if (registry.has('blue')) {
-   *   console.log('Blue theme exists');
-   * }
-   * ```
+    return this.storage.toObject();
+  }
+  /**
+   * Check whether a key exists.
    */
   has(key) {
-    return this.collection.has(key);
+    return this.storage.has(key);
   }
   /**
-   * Remove an item from the registry
-   * 
-   * Removes an item with the specified key from the registry.
-   * Returns true if the item was removed, false if it didn't exist.
-   * 
-   * Time Complexity: O(1)
-   * 
-   * @param key - Item identifier to remove
-   * @returns True if item was removed, false if it didn't exist
-   * 
-   * @example
-   * ```typescript
-   * const removed = registry.remove('blue');
-   * ```
+   * Remove an item by key.
+   *
+   * @returns `true` if the key existed and was removed
    */
   remove(key) {
-    return this.collection.remove(key);
+    return this.storage.delete(key);
   }
   /**
-   * Clear all items from the registry
-   * 
-   * Removes all items from the registry, leaving it empty.
-   * This operation is irreversible.
-   * 
-   * Time Complexity: O(1)
-   * 
-   * @example
-   * ```typescript
-   * registry.clear();
-   * ```
+   * Remove all items from the registry.
    */
   clear() {
-    this.collection.clear();
-  }
-  /**
-   * Get the number of items in the registry
-   * 
-   * Returns the total count of items currently registered.
-   * 
-   * Time Complexity: O(1)
-   * 
-   * @returns Number of items in the registry
-   * 
-   * @example
-   * ```typescript
-   * console.log(registry.size()); // 2
-   * ```
-   */
-  size() {
-    return this.collection.size();
-  }
-  /**
-   * Check if the registry is empty
-   * 
-   * Returns true if the registry contains no items, false otherwise.
-   * This is a convenience method equivalent to checking if size() === 0.
-   * 
-   * Time Complexity: O(1)
-   * 
-   * @returns True if registry has no items, false otherwise
-   * 
-   * @example
-   * ```typescript
-   * console.log(registry.isEmpty()); // true
-   * ```
-   */
-  isEmpty() {
-    return this.collection.isEmpty();
+    this.storage.clear();
   }
   /**
-   * Iterate over all items in the registry
-   * 
-   * Executes a callback function for each item in the registry.
-   * Items are iterated in insertion order (for MapCollection).
-   * 
-   * Time Complexity: O(n) where n is the number of items
-   * 
-   * @param callback - Function to call for each item (value, key)
-   * 
-   * @example
-   * ```typescript
-   * registry.forEach((theme, key) => {
-   *   console.log(`${key}: ${theme.name}`);
-   * });
-   * ```
+   * Return the number of registered items.
    */
-  forEach(callback) {
-    this.collection.forEach(callback);
-  }
-  /**
-   * Map over all items in the registry
-   * 
-   * Transforms each item in the registry using a callback function
-   * and returns an array of the transformed values.
-   * 
-   * Time Complexity: O(n) where n is the number of items
-   * 
-   * @template U - The type of the transformed items
-   * @param callback - Function to transform each item (value, key) => U
-   * @returns Array of transformed items
-   * 
-   * @example
-   * ```typescript
-   * const names = registry.map(theme => theme.name);
-   * ```
-   */
-  map(callback) {
-    return this.collection.map(callback);
-  }
-  /**
-   * Filter items in the registry
-   * 
-   * Returns an array of items that pass the test implemented by the
-   * provided predicate function.
-   * 
-   * Time Complexity: O(n) where n is the number of items
-   * 
-   * @param predicate - Function to test each item (value, key) => boolean
-   * @returns Array of items that pass the test
-   * 
-   * @example
-   * ```typescript
-   * const darkThemes = registry.filter(theme => theme.isDark);
-   * ```
-   */
-  filter(predicate) {
-    return this.collection.filter(predicate);
-  }
-  /**
-   * Find an item in the registry
-   * 
-   * Returns the first item that satisfies the provided predicate function.
-   * Returns undefined if no item passes the test.
-   * 
-   * Time Complexity: O(n) worst case, O(1) best case
-   * 
-   * @param predicate - Function to test each item (value, key) => boolean
-   * @returns First item that passes the test, or undefined
-   * 
-   * @example
-   * ```typescript
-   * const defaultTheme = registry.find(theme => theme.isDefault);
-   * ```
-   */
-  find(predicate) {
-    return this.collection.find(predicate);
+  size() {
+    return this.storage.size();
   }
-};
-
-// src/facades/facade.ts
-var import_react_di = require("@abdokouta/react-di");
-
-// src/facades/facade.interface.ts
-function isFake(obj) {
-  return typeof obj === "object" && obj !== null && "__isFake" in obj && obj.__isFake === true;
-}
-
-// src/facades/facade.ts
-var Facade = class {
   /**
-   * Hotswap the underlying instance behind the facade
-   *
-   * Useful for testing - swap the real service with a mock or fake.
-   *
-   * @param instance - Instance to swap in
-   *
-   * @example
-   * ```typescript
-   * // In tests
-   * const mockLogger = { info: vi.fn(), error: vi.fn() };
-   * Log.swap(mockLogger);
-   *
-   * // Now Log.info() calls mockLogger.info()
-   * Log.info('test');
-   * expect(mockLogger.info).toHaveBeenCalledWith('test');
-   * ```
+   * Return `true` when the registry is empty.
    */
-  static swap(instance) {
-    const accessor = this.getFacadeAccessor();
-    const key = this.getAccessorKey(accessor);
-    this.resolvedInstance.set(key, instance);
+  isEmpty() {
+    return this.storage.isEmpty();
   }
   /**
-   * Determines whether a "fake" has been set as the facade instance
-   *
-   * @returns True if the current instance is a Fake
-   *
-   * @example
-   * ```typescript
-   * if (Log.isFake()) {
-   *   console.log('Using fake logger');
-   * }
-   * ```
+   * Iterate over every entry in insertion order.
    */
-  static isFake() {
-    const accessor = this.getFacadeAccessor();
-    const key = this.getAccessorKey(accessor);
-    const instance = this.resolvedInstance.get(key);
-    return instance !== void 0 && isFake(instance);
+  forEach(callback) {
+    this.storage.each((value, key) => {
+      callback(value, key);
+    });
   }
   /**
-   * Get the root object behind the facade
-   *
-   * Resolves and returns the actual service instance.
-   *
-   * @returns The resolved service instance
+   * Map every entry to a new value and return the results as an array.
    */
-  static getFacadeRoot() {
-    return this.resolveFacadeInstance(this.getFacadeAccessor());
+  map(callback) {
+    const result = [];
+    this.storage.each((value, key) => {
+      result.push(callback(value, key));
+    });
+    return result;
   }
   /**
-   * Get the registered name of the component
-   *
-   * Subclasses MUST override this method to specify which service
-   * the facade represents.
-   *
-   * @returns Service identifier (string, symbol, or class)
-   * @throws Error if not implemented
-   *
-   * @example
-   * ```typescript
-   * class Log extends Facade {
-   *   protected static getFacadeAccessor(): ServiceIdentifier {
-   *     return LoggerService; // or 'logger' string token
-   *   }
-   * }
-   * ```
+   * Return all values whose entries satisfy the predicate.
    */
-  static getFacadeAccessor() {
-    throw new Error("Facade does not implement getFacadeAccessor method.");
+  filter(predicate) {
+    const result = [];
+    this.storage.each((value, key) => {
+      if (predicate(value, key)) {
+        result.push(value);
+      }
+    });
+    return result;
   }
   /**
-   * Get a consistent key for the accessor
+   * Return the first value whose entry satisfies the predicate.
    */
-  static getAccessorKey(accessor) {
-    if (typeof accessor === "function") {
-      return accessor.name || accessor.toString();
-    }
-    return accessor;
+  find(predicate) {
+    return this.storage.first(predicate);
   }
-  /**
-   * Resolve the facade root instance from the container
+};
+
+// src/managers/multiple-instance-manager.ts
+var MultipleInstanceManager = class {
+  constructor() {
+    // ──────────────────────────────────────────────────────────────────────────
+    // State
+    // ──────────────────────────────────────────────────────────────────────────
+    /**
+     * Resolved instances, keyed by instance name.
+     * Instances are created once and reused on subsequent calls.
+     */
+    __publicField(this, "instances", /* @__PURE__ */ new Map());
+    /**
+     * Custom driver creators registered via `extend()`.
+     * Keyed by driver name.
+     */
+    __publicField(this, "customCreators", /* @__PURE__ */ new Map());
+    /**
+     * The config key that identifies the driver.
+     * Override in subclasses if your config uses a different field name.
+     *
+     * @default 'driver'
+     */
+    __publicField(this, "driverKey", "driver");
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Public API
+  // ──────────────────────────────────────────────────────────────────────────
+  /**
+   * Get an instance by name.
    *
-   * @param identifier - Service identifier
-   * @returns Resolved service instance
-   */
-  static resolveFacadeInstance(identifier) {
-    const key = this.getAccessorKey(identifier);
-    if (this.resolvedInstance.has(key)) {
-      return this.resolvedInstance.get(key);
-    }
-    const container = this.getContainer();
-    if (!container) {
-      throw new Error(
-        `Unable to resolve facade instance. Module not set. Call Facade.setFacadeModule(YourModule) first.`
-      );
-    }
-    const instance = container.get(identifier);
-    if (this.cached) {
-      this.resolvedInstance.set(key, instance);
-    }
-    return instance;
-  }
-  /**
-   * Get the module container
+   * Returns a cached instance if available, otherwise resolves and caches it.
+   * If no name is provided, returns the default instance.
    *
-   * @returns The module container instance
-   */
-  static getContainer() {
-    if (this.container) {
-      return this.container;
+   * @param name - Instance name (uses default if omitted)
+   * @returns The resolved instance
+   * @throws Error if the instance is not configured
+   */
+  instance(name) {
+    const instanceName = name ?? this.getDefaultInstance();
+    const existing = this.instances.get(instanceName);
+    if (existing) {
+      return existing;
     }
-    if (this.moduleClass) {
-      this.container = (0, import_react_di.getModuleContainer)(this.moduleClass);
-      return this.container;
-    }
-    return null;
+    const resolved = this.resolve(instanceName);
+    this.instances.set(instanceName, resolved);
+    return resolved;
   }
   /**
-   * Clear a resolved facade instance
+   * Register a custom driver creator.
    *
-   * @param name - Service identifier to clear (defaults to this facade's accessor)
-   */
-  static clearResolvedInstance(name) {
-    const key = name ?? this.getAccessorKey(this.getFacadeAccessor());
-    this.resolvedInstance.delete(key);
-  }
-  /**
-   * Clear all resolved instances
+   * Custom creators take priority over built-in drivers.
    *
-   * Useful for test cleanup.
+   * @param driver - Driver name
+   * @param creator - Factory function that creates an instance from config
+   * @returns this (for chaining)
    */
-  static clearResolvedInstances() {
-    this.resolvedInstance.clear();
+  extend(driver, creator) {
+    this.customCreators.set(driver, creator);
+    return this;
   }
   /**
-   * Get the module class
+   * Remove a cached instance, forcing re-creation on next access.
    *
-   * @returns The module class
+   * @param name - Instance name (uses default if omitted)
+   * @returns this (for chaining)
    */
-  static getFacadeModule() {
-    return this.moduleClass;
+  forgetInstance(name) {
+    const instanceName = name ?? this.getDefaultInstance();
+    this.instances.delete(instanceName);
+    return this;
   }
   /**
-   * Set the module class for facade resolution
-   *
-   * Must be called during application bootstrap to enable facades.
-   * Call this AFTER Inversiland.run() or Container.configure().build().
-   *
-   * @param module - The root module class
-   *
-   * @example
-   * ```typescript
-   * // In your app bootstrap (main.tsx)
-   * import { Facade } from '@abdokouta/react-support';
-   * import { Container, ContainerProvider } from '@abdokouta/react-di';
-   * import { AppModule } from './app.module';
-   *
-   * // Initialize container
-   * Container.configure().withModule(AppModule).withDefaults().build();
-   *
-   * // Set facade module
-   * Facade.setFacadeModule(AppModule);
-   *
-   * // Now facades work anywhere
-   * ReactDOM.createRoot(document.getElementById("root")!).render(
-   *   <ContainerProvider module={AppModule}>
-   *     <App />
-   *   </ContainerProvider>
-   * );
-   * ```
+   * Remove all cached instances.
    */
-  static setFacadeModule(module2) {
-    this.moduleClass = module2;
-    this.container = null;
+  purge() {
+    this.instances.clear();
   }
   /**
-   * Set the container directly (alternative to setFacadeModule)
+   * Check if an instance has been resolved and cached.
    *
-   * @param container - The module container instance
+   * @param name - Instance name
    */
-  static setFacadeContainer(container) {
-    this.container = container;
+  hasResolvedInstance(name) {
+    return this.instances.has(name);
   }
-  // ============================================================================
-  // Legacy API (for compatibility with FacadeApplication interface)
-  // ============================================================================
   /**
-   * @deprecated Use setFacadeModule instead
+   * Get all resolved instance names.
    */
-  static setFacadeApplication(app) {
-    if (app) {
-      this.container = {
-        get: (id) => app.get(id)
-      };
-    } else {
-      this.container = null;
-    }
+  getResolvedInstances() {
+    return Array.from(this.instances.keys());
   }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Resolution (private)
+  // ──────────────────────────────────────────────────────────────────────────
   /**
-   * @deprecated Use getFacadeModule instead
+   * Resolve an instance by name.
+   *
+   * 1. Reads config via `getInstanceConfig()` (from injected config)
+   * 2. Extracts the driver name from the config
+   * 3. Checks custom creators first
+   * 4. Falls back to `createDriver()`
+   *
+   * @param name - Instance name
+   * @returns A new instance
    */
-  static getFacadeApplication() {
-    const container = this.getContainer();
-    if (!container) return null;
-    return {
-      get: (abstract) => container.get(abstract)
-    };
-  }
-};
-/**
- * The root module class for resolving services
- */
-Facade.moduleClass = null;
-/**
- * The module container instance (cached)
- */
-Facade.container = null;
-/**
- * The resolved object instances
- *
- * Caches resolved instances by their accessor key for performance.
- */
-Facade.resolvedInstance = /* @__PURE__ */ new Map();
-/**
- * Indicates if the resolved instance should be cached
- *
- * Set to false in subclasses to always resolve fresh instances.
- */
-Facade.cached = true;
-
-// src/facades/create-facade.ts
-var import_react_di2 = require("@abdokouta/react-di");
-function createFacade(options) {
-  const { accessor, cached = true } = options;
-  class ConcreteFacade extends Facade {
-    static getFacadeAccessor() {
-      return accessor;
+  resolve(name) {
+    const config = this.getInstanceConfig(name);
+    if (!config) {
+      throw new Error(`Instance [${name}] is not defined.`);
     }
-  }
-  ConcreteFacade.cached = cached;
-  const proxy = new Proxy(ConcreteFacade, {
-    get(target, prop, receiver) {
-      if (prop in target) {
-        const value = Reflect.get(target, prop, receiver);
-        if (typeof value === "function") {
-          return value.bind(target);
-        }
-        return value;
-      }
-      return (...args) => {
-        const instance = target.getFacadeRoot();
-        if (!instance) {
-          throw new Error(
-            `A facade root has not been set. Call Facade.setFacadeModule() first.`
-          );
-        }
-        const method = instance[prop];
-        if (typeof method !== "function") {
-          throw new Error(
-            `Method "${String(prop)}" does not exist on the facade root.`
-          );
-        }
-        return method.apply(instance, args);
-      };
+    const driver = config[this.driverKey];
+    if (!driver) {
+      throw new Error(`Instance [${name}] does not specify a "${this.driverKey}".`);
     }
-  });
-  return proxy;
-}
-function createFacadeClass(accessor) {
-  return class extends Facade {
-    static getFacadeAccessor() {
-      return accessor;
+    const customCreator = this.customCreators.get(driver);
+    if (customCreator) {
+      return customCreator(config);
     }
-  };
-}
-function getContainerFromModule(moduleClass) {
-  return (0, import_react_di2.getModuleContainer)(moduleClass);
-}
+    return this.createDriver(driver, config);
+  }
+};
 //# sourceMappingURL=index.js.map