@wirestate/lit 0.7.0-experimental.1 → 0.7.0-experimental.2

package/index.d.ts

@@ -1,13 +1,7 @@
 import { ReactiveElement, ReactiveControllerHost, ReactiveController } from '@lit/reactive-element';
-import { ServiceIdentifier, CommandType, CommandHandler, Event, EventType, EventHandler, QueryType, QueryHandler, Container, Newable, InjectableDescriptor, SeedEntries } from '@wirestate/core';
+import { ServiceIdentifier, Container as Container$1, WireScope, CommandType, CommandHandler, Event, EventType, EventHandler, QueryType, QueryHandler, CreateContainerOptions, Newable, InjectableDescriptor, SeedEntries } from '@wirestate/core';
 import { ContextProvider, ContextConsumer } from '@lit/context';
 
-/**
- * Any object with string or symbol keys.
- *
- * @group Types
- */
-type AnyObject = Record<string | symbol, any>;
 /**
  * Type that can be null.
  *
@@ -20,6 +14,12 @@ type Optional<T> = T | null;
  * @group Types
  */
 type MaybePromise<T> = T | Promise<T>;
+/**
+ * Value that can be null or undefined.
+ *
+ * @group Types
+ */
+type Maybe<T> = T | null | undefined;
 /**
  * Helper to extract the interface of a type.
  *
@@ -114,6 +114,41 @@ interface InjectionOptions<T> {
  */
 declare function injection<T>(optionsOrInjectionId: InjectionOptions<T> | ServiceIdentifier<T>): InjectionDecorator<T>;
 
+/**
+ * Represents result of the {@link useContainer} hook.
+ *
+ * @group Consumption
+ */
+interface UseContainerValue {
+    /**
+     * The active container from the nearest parent context.
+     */
+    value: Container$1;
+}
+/**
+ * Hook (consumer) to access the active container from the nearest parent context.
+ *
+ * @remarks
+ * The returned value updates when the nearest provided container changes.
+ *
+ * @group Consumption
+ *
+ * @param host - The host element.
+ * @returns An instance of {@link UseContainerValue}.
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private container: UseContainerValue = useContainer(this);
+ *
+ *   public render() {
+ *     return html`<div>${this.container.value.isBound(MyService)}</div>`;
+ *   }
+ * }
+ * ```
+ */
+declare function useContainer<E extends ReactiveControllerHost & HTMLElement>(host: E): UseContainerValue;
+
 /**
  * Represents options for the {@link useInjection} hook.
  *
@@ -185,6 +220,37 @@ interface UseInjectionValue<T> {
  */
 declare function useInjection<T extends object, E extends ReactiveControllerHost & HTMLElement>(host: E, optionsOrInjectionId: UseInjectionOptions<T> | ServiceIdentifier<T>): UseInjectionValue<T>;
 
+/**
+ * Represents result of the {@link useScope} hook.
+ *
+ * @group Consumption
+ */
+type UseScopeValue = UseInjectionValue<WireScope>;
+/**
+ * Hook (consumer) to access the active {@link WireScope} from the nearest parent context.
+ *
+ * @remarks
+ * The returned value updates when the nearest provided container changes.
+ *
+ * @group Consumption
+ *
+ * @param host - The host element.
+ * @returns An instance of {@link UseScopeValue}.
+ *
+ * @example
+ * ```typescript
+ * class MyElement extends LitElement {
+ *   private scope: UseScopeValue = useScope(this);
+ *
+ *   public connectedCallback(): void {
+ *     super.connectedCallback();
+ *     this.scope.value.emitEvent("UI_READY");
+ *   }
+ * }
+ * ```
+ */
+declare function useScope<E extends ReactiveControllerHost & HTMLElement>(host: E): UseScopeValue;
+
 /**
  * Represents interface for the {@link onCommand} decorator.
  *
@@ -512,286 +578,315 @@ interface UseOnQueryOptions<D = unknown, R = unknown> {
 declare function useOnQuery<D = unknown, R = unknown>(host: ReactiveElement, { type, handler }: UseOnQueryOptions<D, R>): OnQueryController<D, R>;
 
 /**
- * Interface for the IoC context value.
- *
- * @group Context
- */
-interface IocContext {
-    /**
-     * The IoC container instance.
-     */
-    readonly container: Container;
-    /**
-     * Revision counter for cache invalidation.
-     */
-    readonly revision: number;
-    /**
-     * Function to force a revision update.
-     */
-    readonly nextRevision: () => number;
-}
-/**
- * Lit context object for providing and consuming the IoC container.
+ * Lit context object for providing and consuming the container.
  *
  * @group Context
  */
-declare const IocContextObject: {
-    __context__: IocContext;
+declare const ContainerContext: {
+    __context__: Container;
 };
 
 /**
- * Represents options for the {@link IocProviderController}.
+ * Represents options for the {@link ContainerProvider}.
+ *
+ * @remarks
+ * Provide either an external `container` or managed creation `options`, but
+ * never both at the same time.
  *
  * @group Provision
  */
-interface IocProviderControllerOptions {
+interface ContainerProviderOptions {
     /**
-     * Optional existing container to use. If not provided, a new one will be created.
+     * External container instance to provide as-is.
+     *
+     * @remarks
+     * External containers are never activated, recreated, or disposed by this
+     * provider.
      */
-    container?: Container;
+    readonly container?: Container$1;
     /**
-     * Optional seed data to apply to the container.
+     * Managed container creation options.
+     *
+     * @remarks
+     * The managed container is created during provider construction without
+     * eager activation, activated when the host connects, disposed when it
+     * disconnects, and recreated on the next reconnect.
      */
-    seed?: AnyObject;
+    readonly options?: CreateContainerOptions;
 }
 /**
- * Controller that provides an IoC container context to the host element and its children.
+ * Provider that exposes an IoC container context to the host element and its children.
  *
  * @remarks
- * It manages the lifecycle of the container and handles revision updates to notify consumers.
- * The container is created (or used from options) when the controller is instantiated.
- * Seed data is applied when the host connects.
+ * The provider supports two modes:
+ *
+ * - External mode: `container` is an existing {@link Container}. The
+ *   provider passes it through context and does not alter its lifecycle.
+ * - Managed mode: `options` is {@link CreateContainerOptions}. The provider
+ *   creates a container during construction without eager activation,
+ *   activates configured entries when the host connects, disposes the
+ *   container when the host disconnects, and recreates it on reconnect.
  *
  * @group Provision
  */
-declare class IocProviderController<E extends ReactiveControllerHost & HTMLElement = ReactiveControllerHost & HTMLElement> implements ReactiveController {
-    private readonly host;
-    protected readonly provider: ContextProvider<typeof IocContextObject>;
-    protected readonly seed?: AnyObject;
-    protected revision: number;
-    /**
-     * The managed Inversify IoC container.
-     */
-    container: Container;
-    /**
-     * @returns Current {@link IocContext} value served to child consumers.
-     */
-    get value(): IocContext;
+declare class ContainerProvider<E extends ReactiveControllerHost & HTMLElement = ReactiveControllerHost & HTMLElement> extends ContextProvider<typeof ContainerContext, E> implements ReactiveController {
+    protected readonly options: Maybe<CreateContainerOptions>;
+    protected destroyed: boolean;
     /**
      * @param host - The host element.
      * @param options - Provisioning options.
-     * @param options.container - Optional existing container to use. If not provided, a new one will be created.
-     * @param options.seed - Optional seed data to apply to the container.
+     * @param options.container - External container instance to provide.
+     * @param options.options - Managed container creation options.
      */
-    constructor(host: E, { container, seed }?: IocProviderControllerOptions);
+    constructor(host: E, options: ContainerProviderOptions);
     hostConnected(): void;
     hostDisconnected(): void;
-    nextRevision(): number;
 }
 
 /**
- * Represents interface for the {@link iocProvide} decorator.
- *
- * @remarks
- * Supports both TC39 and legacy experimental decorators.
+ * Represents options for the {@link SubContainerProvider}.
  *
  * @group Provision
  */
-interface IocProviderDecorator<E extends ReactiveElement = ReactiveElement> {
-    <C extends Interface<Omit<ReactiveElement, "renderRoot">>, V extends IocProviderController<E>>(value: ClassAccessorDecoratorTarget<C, V>, context: ClassAccessorDecoratorContext<C, V>): void;
-    <K extends PropertyKey, Proto extends Interface<Omit<ReactiveElement, "renderRoot">>>(protoOrDescriptor: Proto, name?: K): FieldMustMatchProvidedType<Proto, K, IocProviderController<E>>;
+interface SubContainerProviderOptions {
+    /**
+     * Managed child-container creation options.
+     *
+     * @remarks
+     * The child container is created from the current parent context when the
+     * host connects, destroyed when the host disconnects, and recreated when the
+     * parent context changes or the host reconnects.
+     */
+    readonly options: {
+        /**
+         * List of service entries to bind to the container.
+         */
+        readonly entries: ReadonlyArray<Newable<object> | InjectableDescriptor>;
+        /**
+         * List of service identifiers to activate (get from container) immediately after binding.
+         */
+        readonly activate?: ReadonlyArray<ServiceIdentifier>;
+        /**
+         * Seed data to apply to the container before binding.
+         * Applied before entries are bound so that `@Inject(SEEDS_TOKEN)` works during activation.
+         */
+        readonly seeds?: SeedEntries;
+    };
 }
 /**
- * Decorator that provides an IoC container to child components.
+ * Provider that exposes a managed child container for the host element's lifetime.
  *
  * @remarks
- * The container is provided via Lit context. It is created (or used from options) when the host connects.
+ * The provider always owns a child container derived from the nearest parent
+ * {@link ContainerContext}. When connected, it creates a child container using
+ * the latest parent context, provides it to descendants, destroys it when the
+ * host disconnects, and replaces it whenever the parent container changes.
  *
  * @group Provision
  *
- * @param options - Provisioning options.
- * @param options.container - Optional existing container to use, if not provided, a new one will be created.
- * @param options.seed - Optional seed data to apply to the container.
- * @returns An instance of {@link IocProviderDecorator}.
- *
  * @example
  * ```typescript
- * class MyRootElement extends LitElement {
- *   @iocProvide({ seed: { someData: "value" } })
- *   private ioc!: IocProviderController;
+ * class MyComponent extends LitElement {
+ *   private container = new SubContainerProvider(this, {
+ *     options: {
+ *       entries: [AuthService, UserService],
+ *       activate: [AuthService],
+ *       seeds: [[AuthService, { role: "admin" }]],
+ *     },
+ *   });
  * }
  * ```
  */
-declare function iocProvide<E extends ReactiveElement>({ container, seed, }?: IocProviderControllerOptions): IocProviderDecorator<E>;
-
-/**
- * Represents a function that returns a value of type `T`.
- *
- * @group general-types
- *
- * @template T - The return type of the function.
- */
-type Callable<T> = () => T;
-
-/**
- * Represents options for the {@link InjectablesProviderController}.
- *
- * @group Provision
- */
-interface InjectablesProviderControllerOptions {
-    /**
-     * List of service entries to bind to the container.
-     */
-    entries: ReadonlyArray<Newable<object> | InjectableDescriptor>;
+declare class SubContainerProvider<E extends ReactiveControllerHost & HTMLElement = ReactiveControllerHost & HTMLElement> extends ContextProvider<typeof ContainerContext, E> implements ReactiveController {
+    protected readonly consumer: ContextConsumer<typeof ContainerContext, E>;
+    protected readonly options: SubContainerProviderOptions["options"];
+    protected parent: Maybe<Container$1>;
+    protected destroyed: boolean;
     /**
-     * Target IoC context to bind injectables into.
-     * If not provided, uses the context from the nearest provider.
-     * Accepts a static {@link IocContext} reference or a resolver function.
+     * @param host - The host element.
+     * @param options - Provisioning options, including child entries, eager activations, and seeds.
      */
-    into?: IocContext | Callable<IocContext>;
+    constructor(host: E, options: SubContainerProviderOptions);
+    hostConnected(): void;
+    hostDisconnected(): void;
     /**
-     * List of service identifiers to activate (get from container) immediately after binding.
+     * Replaces the currently provided child container with a new one derived
+     * from the latest parent context.
      */
-    activate?: ReadonlyArray<ServiceIdentifier>;
+    protected createContainer(): void;
     /**
-     * Seed data to apply to the container before binding.
-     * Applied before entries are bound so that `@Inject(SEEDS_TOKEN)` works during activation.
+     * Destroys the currently provided child container.
      */
-    seeds?: SeedEntries;
+    protected destroyContainer(): void;
+}
+
+/**
+ * Represents interface for the {@link containerProvide} decorator.
+ *
+ * @remarks
+ * Supports both TC39 and legacy experimental decorators.
+ *
+ * @group Provision
+ */
+interface ContainerProviderDecorator<E extends ReactiveElement = ReactiveElement> {
+    <C extends Interface<Omit<ReactiveElement, "renderRoot">>, V extends ContainerProvider<E>>(value: ClassAccessorDecoratorTarget<C, V>, context: ClassAccessorDecoratorContext<C, V>): void;
+    <K extends PropertyKey, Proto extends Interface<Omit<ReactiveElement, "renderRoot">>>(protoOrDescriptor: Proto, name?: K): FieldMustMatchProvidedType<Proto, K, ContainerProvider<E>>;
 }
 /**
- * Controller that binds injectables to an IoC container for the host element's lifetime.
+ * Decorator that provides an IoC container to child components.
  *
  * @remarks
- * Entries are bound when the host connects and unbound when it disconnects.
- * If no `into` context is provided, it uses the nearest {@link IocProviderController}.
- * Seeds are applied before entries are bound.
+ * The container is provided via Lit context.
+ *
+ * - Pass `container` to expose an external container without taking
+ *   ownership.
+ * - Pass `options` to create a managed container during construction,
+ *   activate configured entries on connect, destroy it on disconnect, and
+ *   recreate it on reconnect.
  *
  * @group Provision
  *
+ * @param options - Provisioning options.
+ * @param options.container - External container instance to provide.
+ * @param options.options - Managed container creation options.
+ * @returns An instance of {@link ContainerProviderDecorator}.
+ *
  * @example
  * ```typescript
- * class MyComponent extends LitElement {
- *   private services = new InjectablesProviderController(this, {
- *     entries: [AuthService, UserService],
- *     activate: [AuthService],
- *     seeds: [[AuthService, { role: "admin" }]],
- *   });
+ * class MyRootElement extends LitElement {
+ *   @containerProvide({
+ *     options: {
+ *       seed: { someData: "value" },
+ *       entries: [LoggerService],
+ *     },
+ *   })
+ *   private containerProvider!: ContainerProvider;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * class MyRootElement extends LitElement {
+ *   @containerProvide({ container: container })
+ *   private containerProvider!: ContainerProvider;
  * }
  * ```
  */
-declare class InjectablesProviderController<E extends ReactiveControllerHost & HTMLElement = ReactiveControllerHost & HTMLElement> implements ReactiveController {
-    private readonly host;
-    protected readonly consumer?: ContextConsumer<typeof IocContextObject, E>;
-    private readonly entries;
-    private readonly activate;
-    private readonly seeds;
-    private readonly into;
-    /**
-     * Tracks the context to which entries are currently bound, for correct cleanup on disconnect.
-     */
-    private boundContext;
-    /**
-     * @param host - The host element.
-     * @param options - Provisioning options.
-     * @param options.entries - List of service entries to bind to the container.
-     * @param options.into - Target IoC context; if omitted, uses the nearest provider context.
-     * @param options.activate - List of service identifiers to activate immediately after binding.
-     * @param options.seeds - Seed data applied before binding.
-     */
-    constructor(host: E, options: InjectablesProviderControllerOptions);
-    hostConnected(): void;
-    hostDisconnected(): void;
-    private bind;
-    private unbind;
-}
+declare function containerProvide<E extends ReactiveElement>(options: ContainerProviderOptions): ContainerProviderDecorator<E>;
 
 /**
- * Represents type for the {@link injectablesProvide} decorator.
+ * Represents type for the {@link subContainerProvide} decorator.
  *
  * @remarks
  * Supports both TC39 and legacy experimental decorators.
  *
  * @group Provision
  */
-interface InjectablesProviderDecorator<T extends ReactiveElement = ReactiveElement> {
-    <C extends Interface<Omit<ReactiveElement, "renderRoot">>, V extends InjectablesProviderController<T>>(value: ClassAccessorDecoratorTarget<C, V>, context: ClassAccessorDecoratorContext<C, V>): void;
-    <K extends PropertyKey, Proto extends Interface<Omit<ReactiveElement, "renderRoot">>>(protoOrDescriptor: Proto, name?: K): FieldMustMatchProvidedType<Proto, K, InjectablesProviderController<T>>;
+interface SubContainerProviderDecorator<T extends ReactiveElement = ReactiveElement> {
+    <C extends Interface<Omit<ReactiveElement, "renderRoot">>, V extends SubContainerProvider<T>>(value: ClassAccessorDecoratorTarget<C, V>, context: ClassAccessorDecoratorContext<C, V>): void;
+    <K extends PropertyKey, Proto extends Interface<Omit<ReactiveElement, "renderRoot">>>(protoOrDescriptor: Proto, name?: K): FieldMustMatchProvidedType<Proto, K, SubContainerProvider<T>>;
 }
 /**
- * Decorator that binds a set of injectables to the nearest IoC container for the host element's lifetime.
+ * Decorator that provides a managed child container derived from the nearest
+ * parent container context.
  *
  * @remarks
- * Entries are bound when the host connects and unbound when it disconnects.
+ * The child container is created from the current parent context when the host
+ * connects, destroyed when it disconnects, and recreated when the parent
+ * container changes.
  *
  * @group Provision
  *
  * @param options - Provisioning options.
- * @returns An instance of {@link InjectablesProviderDecorator}.
+ * @param options.options - Child-container creation options.
+ * @returns An instance of {@link SubContainerProviderDecorator}.
  *
  * @example
  * ```typescript
  * class MyComponent extends LitElement {
- *   @injectablesProvide({ entries: [AuthService, UserService], activate: [AuthService] })
- *   public controller!: InjectablesProviderController<MyComponent>;
+ *   @subContainerProvide({
+ *     options: {
+ *       entries: [AuthService, UserService],
+ *       activate: [AuthService],
+ *     },
+ *   })
+ *   public containerProvider!: SubContainerProvider<MyComponent>;
  * }
  * ```
  */
-declare function injectablesProvide<E extends ReactiveElement = ReactiveElement>(options: InjectablesProviderControllerOptions): InjectablesProviderDecorator<E>;
+declare function subContainerProvide<E extends ReactiveElement = ReactiveElement>(options: SubContainerProviderOptions): SubContainerProviderDecorator<E>;
 
 /**
- * Hook that binds injectables to the nearest IoC container for the host element's lifetime.
+ * Represents options for the {@link useContainerProvision} hook.
+ *
+ * @group Provision
+ */
+type UseContainerProvisionOptions = ContainerProviderOptions;
+/**
+ * Hook that provides a container to the host element and its children.
+ *
+ * @remarks
+ * Pass `container` to expose an external `Container` without taking
+ * ownership. Pass `options` to create a managed container during
+ * construction, activate configured entries on connect, destroy it on
+ * disconnect, and recreate it on reconnect.
  *
  * @group Provision
  *
  * @param host - The host element.
  * @param options - Provisioning options.
- * @returns An instance of {@link InjectablesProviderController}.
+ * @param options.container - External container instance to provide.
+ * @param options.options - Managed container creation options.
+ * @returns An instance of {@link ContainerProvider}.
  *
  * @example
  * ```typescript
- * class MyComponent extends LitElement {
- *   private services = useInjectablesProvider(this, {
- *     entries: [AuthService, UserService],
- *     activate: [AuthService],
+ * class MyRootElement extends LitElement {
+ *   private containerProvider: ContainerProvider = useContainerProvision(this, {
+ *     options: {
+ *       entries: [LoggerService],
+ *       activate: [LoggerService],
+ *     },
  *   });
  * }
  * ```
+ *
+ * @example
+ * ```typescript
+ * class MyRootElement extends LitElement {
+ *   private containerProvider: ContainerProvider = useContainerProvision(this, { container: container });
+ * }
+ * ```
  */
-declare function useInjectablesProvider<E extends ReactiveControllerHost & HTMLElement>(host: E, options: InjectablesProviderControllerOptions): InjectablesProviderController<E>;
+declare function useContainerProvision<E extends ReactiveControllerHost & HTMLElement>(host: E, options: UseContainerProvisionOptions): ContainerProvider<E>;
 
 /**
- * Represents options for the {@link useIocProvision} hook.
+ * Hook that provides a managed child container for the host element's lifetime.
  *
- * @group Provision
- */
-interface UseIocProvisionOptions {
-    /**
-     * Optional existing container to use.
-     */
-    container?: Container;
-    /**
-     * Optional seed data to apply to the container.
-     */
-    seed?: AnyObject;
-}
-/**
- * Hook that provides an IoC container to the host element and its children.
+ * @remarks
+ * The child container is derived from the current parent
+ * {@link ContainerContext}, recreated when that parent context changes, and
+ * destroyed when the host disconnects.
  *
  * @group Provision
  *
  * @param host - The host element.
  * @param options - Provisioning options.
- * @returns An instance of {@link IocProviderController}.
+ * @param options.options - Child-container creation options.
+ * @returns An instance of {@link SubContainerProvider}.
  *
  * @example
  * ```typescript
- * class MyRootElement extends LitElement {
- *   private ioc = useIocProvision(this, { seed: { initialData: "..." } });
+ * class MyComponent extends LitElement {
+ *   private containerProvider: SubContainerProvider = useSubContainerProvider(this, {
+ *     options: {
+ *       entries: [AuthService, UserService],
+ *     },
+ *   });
  * }
  * ```
  */
-declare function useIocProvision<E extends ReactiveControllerHost & HTMLElement>(host: E, options?: UseIocProvisionOptions): IocProviderController<E>;
+declare function useSubContainerProvider<E extends ReactiveControllerHost & HTMLElement>(host: E, options: SubContainerProviderOptions): SubContainerProvider<E>;
 
-export { InjectablesProviderController, IocContextObject, IocProviderController, OnCommandController, OnEventController, OnQueryController, injectablesProvide, injection, iocProvide, onCommand, onEvent, onQuery, useInjectablesProvider, useInjection, useIocProvision, useOnCommand, useOnEvents, useOnQuery };
-export type { InjectablesProviderControllerOptions, InjectablesProviderDecorator, InjectionDecorator, InjectionOptions, IocContext, IocProviderControllerOptions, IocProviderDecorator, OnCommandDecorator, OnEventDecorator, OnQueryDecorator, UseInjectionOptions, UseInjectionValue, UseIocProvisionOptions, UseOnCommandOptions, UseOnEventsOptions, UseOnQueryOptions };
+export { ContainerContext, ContainerProvider, OnCommandController, OnEventController, OnQueryController, SubContainerProvider, containerProvide, injection, onCommand, onEvent, onQuery, subContainerProvide, useContainer, useContainerProvision, useInjection, useOnCommand, useOnEvents, useOnQuery, useScope, useSubContainerProvider };
+export type { ContainerProviderDecorator, ContainerProviderOptions, InjectionDecorator, InjectionOptions, OnCommandDecorator, OnEventDecorator, OnQueryDecorator, SubContainerProviderDecorator, SubContainerProviderOptions, UseContainerProvisionOptions, UseContainerValue, UseInjectionOptions, UseInjectionValue, UseOnCommandOptions, UseOnEventsOptions, UseOnQueryOptions, UseScopeValue };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirestate/lit",
-  "version": "0.7.0-experimental.1",
+  "version": "0.7.0-experimental.2",
   "description": "Lit elements integration for wirestate",
   "sideEffects": false,
   "author": "Syrotenko Igor",
@@ -47,7 +47,7 @@
   ],
   "dependencies": {},
   "peerDependencies": {
-    "@wirestate/core": ">=0.6.0",
+    "@wirestate/core": ">=0.7.0-experimental.1",
     "@lit/reactive-element": ">=2.0.0",
     "@lit/context": ">=1.0.0",
     "reflect-metadata": ">=0.2.0",

package/esm/development/context/ioc-context.js

@@ -1,17 +0,0 @@
-import { createContext } from '@lit/context';
-
-/**
- * Unique symbol used as a key for the IoC context.
- *
- * @group Context
- */
-var IOC_CONTAINER_KEY = Symbol("ContainerContext");
-/**
- * Lit context object for providing and consuming the IoC container.
- *
- * @group Context
- */
-var IocContextObject = createContext(IOC_CONTAINER_KEY);
-
-export { IOC_CONTAINER_KEY, IocContextObject };
-//# sourceMappingURL=ioc-context.js.map

package/esm/development/context/ioc-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ioc-context.js","sources":["../../../../../../../../src/wirestate-lit/context/ioc-context.ts"],"sourcesContent":[null],"names":["IOC_CONTAINER_KEY","Symbol","IocContextObject","createContext"],"mappings":";;AAGA;;;;AAIG;IACUA,iBAAiB,GAAkBC,MAAM,CAAC,kBAAkB;AAsBzE;;;;AAIG;IACUC,gBAAgB,GAAGC,aAAa,CAAaH,iBAAiB;;;;"}