@sdux-vault/core-extensions-angular 0.0.4

package/LICENSE

@@ -0,0 +1,249 @@
+# MIT License
+
+(with SDuX Clarification Notice)
+
+---
+
+## MIT License (Standard Text)
+
+Copyright (c) 2026 NextGen Luminary
+
+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.
+
+---
+
+## SDuX Clarification Notice (Non-License Commentary)
+
+**IMPORTANT:**  
+The following sections are **clarifying notices** provided for transparency, auditability, ecosystem boundary clarity, acquisition readiness, and architectural separation within the SDuX ecosystem. They **do not modify, amend, replace, restrict, supersede, or reinterpret** the MIT License above.
+
+If any conflict is perceived between this clarification notice and the MIT License text above, the MIT License text **controls in all cases**.
+
+The MIT License text above applies **only** to the specific SDuX repositories and npm packages explicitly designated as open source by NextGen Luminary.
+
+---
+
+## 1. Scope of This License
+
+This MIT License applies exclusively to the following SDuX components:
+
+### SDuX Framework Source
+
+- @sdux-vault/core
+- @sdux-vault/add-ons
+- @sdux-vault/shared
+- @sdux-vault/devtools/tooling
+- @sdux-vault/devtools/ui
+- @sdux-vault/ui/web-components
+
+### SDuX Open-Source npm Packages
+
+- Identical package names as listed above when distributed via npm
+
+No other SDuX components are licensed under the MIT License unless explicitly stated in writing by NextGen Luminary.
+
+The MIT License does **not** apply to any repository, package, module, runtime, binary, service, distribution artifact, hosted system, entitlement service, or enforcement subsystem that is not expressly designated as MIT-licensed.
+
+---
+
+## 2. Explicit Exclusion of Proprietary Components
+
+For the avoidance of doubt:
+
+This MIT License **does not apply** to:
+
+- @sdux-vault/engine
+- SDuX Vault runtime components
+- Persistence modules
+- Encryption modules
+- Licensing enforcement modules
+- Telemetry systems
+- Commercial-only features
+- Runtime gating mechanisms
+- Deterministic license validation infrastructure
+- Any proprietary binaries, services, network services, entitlement servers, or internal source code
+
+Use of proprietary SDuX components is governed exclusively by their applicable commercial or community licenses.
+
+No rights—express or implied—are granted to proprietary components by virtue of this MIT License.
+
+In particular, this MIT License does **not** grant rights to:
+
+- Proprietary runtime enforcement systems
+- Deterministic gating or validation logic
+- License timeout mechanisms
+- Runtime license tokens
+- Production-gating systems
+- Commercial entitlement APIs
+- Proprietary network services or validation endpoints
+- Internal orchestration engines not explicitly released under MIT
+
+---
+
+## 3. No Transitive or Implied Licensing
+
+This MIT License:
+
+- Does **not** grant rights to dependencies that are not themselves MIT-licensed
+- Does **not** extend rights to runtime engines, orchestrators, execution layers, or enforcement systems
+- Does **not** create any obligation for NextGen Luminary to open-source additional components
+- Does **not** grant rights to use proprietary licensing APIs, enforcement surfaces, runtime validation endpoints, or commercial network services outside their intended licensed boundaries
+
+Each SDuX package is licensed independently and must be evaluated on its own terms.
+
+No transitive, derivative, architectural, structural, or implied licensing rights arise merely because MIT-licensed components may interoperate with proprietary components.
+
+Interoperability does not imply relicensing, source disclosure obligations, or any grant of rights to non-MIT components.
+
+---
+
+## 4. Use in Commercial and Enterprise Environments
+
+The MIT-licensed SDuX framework components:
+
+- May be used in commercial, enterprise, and production environments
+- May be modified and redistributed in accordance with the MIT License
+- May be included in proprietary products, subject to MIT attribution requirements
+
+This permissive licensing is intentional and designed to:
+
+- Encourage adoption
+- Support long-term maintainability
+- Reduce legal friction during audits and acquisitions
+
+No additional enterprise license is required for the MIT-designated components themselves.
+
+---
+
+## 5. Separation From Third-Party Extensions
+
+Third-party extensions, add-ons, Behaviors, Controllers, integrations, or other modules developed by independent Vendors are **independently licensed**.
+
+This MIT License:
+
+- Does **not** apply to third-party extensions unless explicitly stated by their respective authors
+- Does **not** grant rights to any Vendor-developed Licensed Extension
+- Does **not** modify, override, validate, or enforce any Vendor commercial license
+
+MIT-licensed SDuX components may be used to build extensions.  
+However:
+
+- Any proprietary enforcement components used by such extensions remain separately licensed
+- Runtime gating systems remain governed by their applicable community or commercial licenses
+- Validation, entitlement, or enforcement behavior implemented outside MIT-designated repositories remains subject to its own governing license
+
+No open-source contamination, copyleft effect, reciprocal licensing obligation, or forced disclosure requirement is created by virtue of integrating MIT-licensed SDuX components with proprietary or third-party components.
+
+---
+
+## 6. No Grant of Rights to Commercial Services or APIs
+
+For clarity:
+
+This MIT License does **not** grant rights to:
+
+- Access proprietary commercial APIs
+- Access proprietary network services
+- Access entitlement servers
+- Access validation infrastructure
+- Access hosted SDuX services
+- Bypass production-gating or enforcement systems
+
+Any such rights, if available, are governed exclusively by their respective commercial or community licenses.
+
+---
+
+## 7. Trademark and Branding Clarification
+
+This MIT License does **not** grant any trademark rights in the names, logos, product branding, or service marks of NextGen Luminary or SDuX, except as required for reasonable and customary attribution consistent with the MIT License.
+
+Use of SDuX or NextGen Luminary trademarks in product names, marketplace listings, or marketing materials may require separate permission.
+
+Nothing in this clarification notice modifies the trademark rights (or lack thereof) under the MIT License; it is provided solely for clarity and avoidance of confusion.
+
+---
+
+## 8. Relationship to Other SDuX Licenses
+
+This MIT License operates independently from:
+
+- NGL Commercial License 1.0
+- SDuX / Vault Community License
+- Any enterprise or custom licensing agreements
+
+Possession or use of MIT-licensed SDuX components does **not** grant access to or rights under those other licenses.
+
+Likewise, possession of proprietary SDuX licenses does not alter the terms of the MIT License for designated open-source components.
+
+Each license operates independently and must be interpreted separately.
+
+---
+
+## 9. Assignment and Acquisition Clarity
+
+The MIT License is inherently **assignable** and **transferable**.
+
+Accordingly:
+
+- Use of MIT-licensed SDuX components **does not prevent acquisition**
+- No special approval is required to transfer ownership of products containing these components
+- Auditors and acquiring entities may rely on standard MIT interpretations without exception
+
+This aligns with industry-standard expectations for permissive open-source frameworks.
+
+---
+
+## 10. Audit and Due-Diligence Statement
+
+During security reviews, license audits, or acquisition due diligence:
+
+- MIT-licensed SDuX components should be reviewed as standard permissive open-source software
+- No copyleft, reciprocity, source disclosure, or distribution obligations apply beyond standard MIT attribution
+- No viral or contaminating license effects exist
+- No patent retaliation, field-of-use restrictions, sublicense limitations, or production-gating obligations exist beyond those inherent in MIT
+
+These characteristics are intentional and designed to be acquisition-safe and enterprise-friendly.
+
+---
+
+## 11. No Modification of License Terms
+
+Nothing in this clarification notice:
+
+- Modifies the MIT License text
+- Adds restrictions to the MIT License
+- Removes rights granted by the MIT License
+- Expands rights beyond those granted by the MIT License
+
+If any conflict is perceived between this clarification notice and the MIT License text above, the MIT License text **controls**.
+
+---
+
+## 12. Entire Notice
+
+This document consists of:
+
+1. The unmodified MIT License text
+2. A non-binding clarification notice for transparency, architectural boundary clarity, compliance certainty, and acquisition readiness
+
+Together, they provide a complete and accurate description of how MIT licensing is applied within the SDuX ecosystem.
+
+---
+
+**END OF MIT LICENSE (WITH SDUX CLARIFICATION NOTICE)**

package/README.md

@@ -0,0 +1,207 @@
+# @sdux-vault/core-extensions/angular
+
+> Angular integration layer for SDuX Vault.
+
+`@sdux-vault/core-extensions/angular` provides the **Angular bindings for SDuX Vault**, enabling seamless integration with Angular’s dependency injection, signals, and reactive model.
+
+This package connects the SDuX runtime to Angular applications in a **framework-native, reactive, and declarative way**.
+
+---
+
+## TL;DR
+
+For full documentation, guides, and API references:  
+https://www.sdux-vault.com
+
+---
+
+## Overview
+
+SDuX is built as a layered system:
+
+```plaintext
+shared → engine → core → core-extensions → apps
+           └─────────────────────────────→ devtools
+```
+
+- **apps** → Angular applications
+- **core** → behavior execution runtime
+- **core-extensions/angular** → Angular integration layer (this package)
+- **devtools** → debugging and inspection
+- **engine** → orchestration, conductor, decision engine
+- **shared** → contracts, types, utilities
+
+---
+
+## What This Package Does
+
+This package bridges SDuX Vault with Angular by providing:
+
+- Angular-friendly **state access**
+- integration with **Angular signals**
+- support for **dependency injection (DI)**
+- reactive bindings for **state updates**
+
+It allows SDuX state to behave like a **first-class Angular reactive source**.
+
+---
+
+## What This Package Provides
+
+- **Angular bindings for FeatureCells**
+- **Signal-based state access**
+- **DI-compatible providers**
+- **Reactive state consumption utilities**
+- **Framework-native integration patterns**
+
+---
+
+## Key Concept: Angular Integration
+
+This package adapts SDuX to Angular’s model:
+
+```plaintext
+SDuX state → Angular signal → component/template
+```
+
+This enables:
+
+- automatic UI updates
+- reactive rendering
+- clean separation of state and view
+
+---
+
+## Signals Integration
+
+State is exposed as Angular signals:
+
+- always up-to-date
+- reactive by default
+- safe to consume in templates
+
+```ts
+const state = myFeatureCell.state();
+```
+
+Signals ensure:
+
+- no manual subscriptions
+- no memory leaks
+- consistent reactivity
+
+---
+
+## Dependency Injection (DI)
+
+FeatureCells and related utilities can be registered and consumed via Angular DI:
+
+- injectable services
+- scoped providers
+- application-level configuration
+
+This allows SDuX to integrate naturally with Angular architecture.
+
+---
+
+## Execution Model
+
+```plaintext
+SDuX pipeline (core + engine)
+          ↓
+Angular extension layer
+          ↓
+Angular signals / DI
+          ↓
+components & templates
+```
+
+This package does **not**:
+
+- execute pipelines (core responsibility)
+- make decisions (engine/controllers responsibility)
+
+It only **adapts runtime state to Angular**.
+
+---
+
+## When to Use This Package
+
+Use this package when:
+
+- building Angular applications with SDuX
+- you want signal-based state access
+- you need DI-friendly integration
+- you want reactive UI updates without manual subscriptions
+
+---
+
+## Installation
+
+```bash
+npm install @sdux-vault/core-extensions/angular
+```
+
+---
+
+## Development
+
+### Build
+
+```bash
+npm run build:core-extensions-angular
+```
+
+Output:
+
+```plaintext
+dist/core-extensions/angular
+```
+
+---
+
+### Test
+
+```bash
+npm run test:core-extensions-angular
+```
+
+---
+
+### Verify
+
+```bash
+npm run verify
+```
+
+Includes:
+
+- linting
+- formatting
+- type checking
+- tests
+
+---
+
+## Publishing
+
+See [RELEASE.md](./RELEASE.md) for publishing instructions.
+
+---
+
+## Ecosystem
+
+- `@sdux-vault/addons` — runtime policies and controllers ([README](../addons/README.md))
+- `@sdux-vault/core` — behavior runtime and pipeline execution ([README](../core/README.md))
+- `@sdux-vault/devtools` — observability and debugging layer for runtime inspection ([README](../devtools/tooling/README.md))
+- `@sdux-vault/engine` — orchestration, conductor, decision engine
+- `@sdux-vault/shared` — contracts, types, utilities ([README](../shared/README.md))
+
+---
+
+## License
+
+For full licensing details:  
+https://www.sdux-vault.com/docs/welcome/license#license-texts
+
+MIT © SDuX Vault

package/fesm2022/sdux-vault-core-extensions-angular.mjs

@@ -0,0 +1,359 @@
+import { InjectionToken, inject, signal, computed, DestroyRef, provideAppInitializer } from '@angular/core';
+import { DevMode, registerVersion } from '@sdux-vault/shared';
+import { FeatureCell as FeatureCell$1 } from '@sdux-vault/core';
+import { Subscription } from 'rxjs';
+import { VaultCore, resetVaultForTests } from '@sdux-vault/engine';
+
+/**
+ * Metadata keys used internally by SDuX to annotate FeatureCell classes.
+ *
+ * These string constants are attached directly to the provider class
+ * (via the `@FeatureCell()` decorator) and are later consumed by
+ * the Vault orchestrator when resolving cell identity and state type.
+ *
+ * @constant FEATURE_CELL_KEY
+ * Stores the unique identifier for a FeatureCell.
+ * This value is required and is used during vault registration,
+ * state lookup, debugging, and pipeline analytics.
+ *
+ * @constant FEATURE_CELL_STATE
+ * Stores a *type anchor* for the FeatureCell’s state (TState).
+ * This field contains no runtime value — instead, it allows SDuX
+ * to extract strong generic types from the decorated class, enabling:
+ *   • typed vault injection (`injectVault<T>()`)
+ *   • typed reducers, filters, and merge behaviors
+ *   • fully inferred state signatures across the pipeline
+ *
+ * These metadata keys must remain stable and unique, as they serve
+ * as the primary lookup mechanism for FeatureCell configuration.
+ */
+const VAULT_METADATA_KEYS = {
+    /** Unique FeatureCell identifier assigned by the @FeatureCell decorator. */
+    FEATURE_CELL_KEY: 'vault:feature-cell-key',
+    /**
+     * Type anchor used to infer a FeatureCell’s state type (TState).
+     * This exists for TypeScript inference only and has no runtime value.
+     */
+    FEATURE_CELL_STATE: 'vault:feature-cell-state'
+};
+
+/**
+ * Decorator factory that marks a class as a FeatureCell with an associated state type.
+ *
+ * This function produces a class decorator that attaches identifying metadata
+ * used to associate a FeatureCell instance with a unique key and a compile-time
+ * state type anchor.
+ *
+ * @param key - Unique identifier assigned to the FeatureCell.
+ */
+function FeatureCell(key) {
+    /**
+     * Applies FeatureCell metadata to the decorated class.
+     *
+     * This decorator assigns a stable FeatureCell key and a state type anchor
+     * used for compile-time inference without introducing runtime behavior.
+     *
+     * @param target - The class constructor being decorated.
+     */
+    // eslint-disable-next-line
+    return function (target) {
+        /**
+         * Attaches the unique FeatureCell identifier to the target class.
+         */
+        // eslint-disable-next-line
+        target[VAULT_METADATA_KEYS.FEATURE_CELL_KEY] = key;
+        /**
+         * Attaches a state type anchor to the target class.
+         */
+        // eslint-disable-next-line
+        target[VAULT_METADATA_KEYS.FEATURE_CELL_STATE] = null;
+    };
+}
+
+// angular/feature-cell-di-tokens.ts
+/**
+ * Internal registry mapping FeatureCell keys to Angular injection tokens.
+ *
+ * This map ensures a one-to-one association between a FeatureCell key and its
+ * corresponding InjectionToken instance.
+ */
+// eslint-disable-next-line
+const featureCellTokens = new Map();
+/**
+ * Tracks whether a FeatureCell token has already been requested for injection.
+ *
+ * This is used to enforce single-injection constraints in non-development modes.
+ */
+const featureCellTokenRequested = new Map();
+/**
+ * Creates or retrieves an Angular InjectionToken for a FeatureCell.
+ *
+ * This function enforces uniqueness rules for FeatureCell keys and controls
+ * whether a token is being created or retrieved based on the `isCreate` flag.
+ *
+ * @param key - The unique FeatureCell key.
+ * @param isCreate - Whether the token is being created or retrieved.
+ * @returns The Angular InjectionToken associated with the FeatureCell.
+ */
+function internalAngularFeatureCellToken(key, isCreate) {
+    let token = featureCellTokens.get(key);
+    if (isCreate) {
+        if (featureCellTokens.has(key)) {
+            if (!DevMode.active) {
+                throw new Error(`[vault] Duplicate FeatureCell key detected: "${key}". ` +
+                    `Each FeatureCell must have a unique key. Existing token: "${key}"`);
+            }
+            return featureCellTokens.get(key);
+        }
+        token = new InjectionToken(`FEATURE_CELL:${key}`);
+        featureCellTokens.set(key, token);
+        return token;
+    }
+    else {
+        if (!featureCellTokens.has(key)) {
+            throw new Error(`[vault] FeatureCell token not found for key "${key}". You must call provideFeatureCell() before retrieving this FeatureCell.`);
+        }
+        if (featureCellTokenRequested.has(key)) {
+            if (!DevMode.active) {
+                throw new Error(`[vault] FeatureCell "${key}" can only be injected into a single decorated @FeatureCell service.`);
+            }
+            return featureCellTokens.get(key);
+        }
+        featureCellTokenRequested.set(key, true);
+        return featureCellTokens.get(key);
+    }
+}
+/**
+ * Creates and registers an Angular InjectionToken for a FeatureCell key.
+ *
+ * @param key - The unique FeatureCell key.
+ * @returns The created InjectionToken.
+ */
+function createAngularFeatureCellToken(key) {
+    return internalAngularFeatureCellToken(key, true);
+}
+/**
+ * Retrieves an existing Angular InjectionToken for a FeatureCell key.
+ *
+ * @param key - The unique FeatureCell key.
+ * @returns The existing InjectionToken.
+ */
+function getAngularFeatureCellToken(key) {
+    return internalAngularFeatureCellToken(key, false);
+}
+/**
+ * Resets all FeatureCell token state for development or test isolation.
+ *
+ * This function clears internal token registries and is only active when
+ * development mode is enabled.
+ */
+function resetAngularFeatureCellTokenDevMode() {
+    if (!DevMode.active)
+        return;
+    featureCellTokens.clear();
+    featureCellTokenRequested.clear();
+}
+
+/**
+ * injectVault
+ * @function injectVault
+ * @description
+ * Retrieves the strongly-typed vault instance associated with a
+ * `@FeatureCell()`-decorated class. This function must be called **inside**
+ * the constructor (or instance initializer) of a FeatureCell service.
+ *
+ * This version uses static metadata written by the FeatureCell decorator:
+ *
+ *   target[FEATURE_CELL_KEY] = "myCell"
+ *   target[FEATURE_CELL_STATE] = null as TState
+ *
+ * No Reflect metadata is required.
+ *
+ * @typeParam T - The typed state stored in this FeatureCell.
+ *
+ * @param featureCellClass - The decorated class whose vault should be injected.
+ */
+function injectVault(
+// eslint-disable-next-line
+featureCellClass) {
+    /**
+     * The target
+     */
+    const target = featureCellClass;
+    if (!target) {
+        throw new Error(`injectVault() must be called inside a @FeatureCell()-decorated service and must be given the class reference.`);
+    }
+    /**
+     * Read static metadata created by the FeatureCell decorator
+     */
+    // eslint-disable-next-line
+    const key = target[VAULT_METADATA_KEYS.FEATURE_CELL_KEY];
+    if (!key) {
+        throw new Error(`injectVault() must be called inside a @FeatureCell()-decorated service.`);
+    }
+    /**
+     *  Resolve DI token for this FeatureCell
+     */
+    const token = getAngularFeatureCellToken(key);
+    /**
+     *  Inject the vault instance
+     */
+    return inject(token);
+}
+
+/**
+ * Angular adapter that augments a core FeatureCell with Angular Signal-based state access.
+ *
+ * This class bridges a framework-agnostic FeatureCellBaseShape into an Angular-friendly
+ * representation by subscribing to state emissions and exposing derived, read-only
+ * Angular Signals for value, loading state, error state, and value presence.
+ */
+class AngularFeatureCellAdapter {
+    core;
+    /**
+     * Manages internal subscriptions to the core FeatureCell state stream.
+     */
+    #subscriptions = new Subscription();
+    /**
+     * Signal representing the current pipeline value.
+     */
+    #value = signal(undefined, ...(ngDevMode ? [{ debugName: "#value" }] : /* istanbul ignore next */ []));
+    /**
+     * Signal representing the current error state.
+     */
+    #error = signal(null, ...(ngDevMode ? [{ debugName: "#error" }] : /* istanbul ignore next */ []));
+    /**
+     * Signal representing whether the FeatureCell is currently loading.
+     */
+    #isLoading = signal(false, ...(ngDevMode ? [{ debugName: "#isLoading" }] : /* istanbul ignore next */ []));
+    /**
+     * Computed signal indicating whether a non-null, non-undefined value is present.
+     */
+    #hasValue = computed(() => {
+        const value = this.#value();
+        return value !== null && value !== undefined;
+    }, ...(ngDevMode ? [{ debugName: "#hasValue" }] : /* istanbul ignore next */ []));
+    /**
+     * Angular destroy reference used to coordinate lifecycle teardown.
+     */
+    #destroyRef = inject(DestroyRef);
+    /**
+     * Creates a new AngularFeatureCellAdapter for the provided core FeatureCell.
+     *
+     * @param core - The framework-agnostic FeatureCell instance to adapt.
+     */
+    constructor(core) {
+        this.core = core;
+        this.#subscriptions.add(this.core.state$.subscribe((stateEmitSnapshot) => {
+            this.#isLoading.set(stateEmitSnapshot?.snapshot?.isLoading ?? false);
+            this.#error.set(stateEmitSnapshot?.snapshot?.error ?? null);
+            this.#value.set(stateEmitSnapshot?.snapshot?.value ?? undefined);
+        }));
+        this.#destroyRef.onDestroy(() => this.destroy());
+    }
+    /**
+     * Builds and returns the Angular-augmented FeatureCell instance.
+     *
+     * @returns The FeatureCell with an attached Angular Signal-based state property.
+     */
+    build() {
+        const cell = this.core;
+        Object.defineProperty(cell, 'state', {
+            configurable: true,
+            enumerable: true,
+            get: () => ({
+                isLoading: this.#isLoading.asReadonly(),
+                value: this.#value.asReadonly(),
+                error: this.#error.asReadonly(),
+                hasValue: this.#hasValue
+            })
+        });
+        return cell;
+    }
+    /**
+     * Destroys the adapter by tearing down subscriptions and delegating to the core FeatureCell.
+     *
+     * @returns void
+     */
+    destroy() {
+        this.core.destroy();
+        this.#subscriptions.unsubscribe();
+    }
+}
+
+/**
+ * Angular provider factory that registers and exposes a FeatureCell instance.
+ *
+ * This function creates the dependency injection providers required to construct
+ * a FeatureCell, adapt it for Angular-specific consumption, and register it for
+ * global access using the provided configuration.
+ *
+ * @param service - Angular service type associated with the FeatureCell.
+ * @param descriptor - Configuration object defining the FeatureCell contract.
+ * @param behaviors - Optional list of behavior classes applied to the FeatureCell.
+ * @param controllers - Optional list of controller classes applied to the FeatureCell.
+ * @returns An array of Angular providers that supply the configured FeatureCell.
+ */
+function provideFeatureCell(service, descriptor, behaviors = [], controllers = []) {
+    const angularToken = createAngularFeatureCellToken(descriptor.key);
+    return [
+        {
+            provide: angularToken,
+            useFactory: () => {
+                const coreCell = FeatureCell$1(descriptor, behaviors, controllers);
+                return new AngularFeatureCellAdapter(coreCell).build();
+            }
+        },
+        service
+    ];
+}
+
+/**
+ * Registers and initializes the SDuX Vault core within an Angular application.
+ *
+ * This function sets up the global FeatureCell registry and returns Angular
+ * environment providers that ensure Vault core initialization occurs during
+ * application bootstrap using the supplied configuration.
+ *
+ * @param config - Optional Vault configuration used to initialize core services.
+ * @returns Angular environment providers that perform Vault initialization at app startup.
+ */
+function provideVault(config = {}) {
+    return provideAppInitializer(() => {
+        VaultCore(config);
+    });
+}
+
+function provideVaultTesting(config) {
+    const finalConfig = {
+        devMode: true,
+        logLevel: 'off',
+        ...config // overrides defaults
+    };
+    if (finalConfig?.devMode) {
+        DevMode.setDevMode(true);
+        resetVaultForTests();
+    }
+    return provideVault(finalConfig);
+}
+
+// --- AI Model File Path (DO NOT DELETE) ---
+// FilePath: libs > angular > src > lib > version > version.register.ts
+// Updated: 2026-03-03 08:06
+//	 Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or
+//	 cmd+alt+j (see .vscode/keybindings.json)
+// --- END AI MODEL FILE PATH ---
+const SDUX_PACKAGE = '@sdux-vault/core-extensions-angular';
+const SDUX_VERSION = '0.0.4';
+registerVersion(SDUX_PACKAGE, SDUX_VERSION);
+
+/*
+ * Public API Surface of angular
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { FeatureCell, injectVault, provideFeatureCell, provideVault, provideVaultTesting, resetAngularFeatureCellTokenDevMode };
+//# sourceMappingURL=sdux-vault-core-extensions-angular.mjs.map

package/fesm2022/sdux-vault-core-extensions-angular.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdux-vault-core-extensions-angular.mjs","sources":["../../../../libs/core-extensions/angular/src/lib/constants/metadata-keys.constant.ts","../../../../libs/core-extensions/angular/src/lib/decorators/feature-cell.decorator.ts","../../../../libs/core-extensions/angular/src/lib/tokens/feature-cell-di.token.ts","../../../../libs/core-extensions/angular/src/lib/injectors/feature-vault.injector.ts","../../../../libs/core-extensions/angular/src/lib/providers/feature-cell/feature.cell.adapter.ts","../../../../libs/core-extensions/angular/src/lib/providers/feature-cell/provide-feature-cell.provider.ts","../../../../libs/core-extensions/angular/src/lib/providers/vault/provide-vault.provider.ts","../../../../libs/core-extensions/angular/src/testing/provide-vault-testing.ts","../../../../libs/core-extensions/angular/src/lib/version/version.register.ts","../../../../libs/core-extensions/angular/src/public-api.ts","../../../../libs/core-extensions/angular/src/sdux-vault-core-extensions-angular.ts"],"sourcesContent":["/**\n * Metadata keys used internally by SDuX to annotate FeatureCell classes.\n *\n * These string constants are attached directly to the provider class\n * (via the `@FeatureCell()` decorator) and are later consumed by\n * the Vault orchestrator when resolving cell identity and state type.\n *\n * @constant FEATURE_CELL_KEY\n * Stores the unique identifier for a FeatureCell.\n * This value is required and is used during vault registration,\n * state lookup, debugging, and pipeline analytics.\n *\n * @constant FEATURE_CELL_STATE\n * Stores a *type anchor* for the FeatureCell’s state (TState).\n * This field contains no runtime value — instead, it allows SDuX\n * to extract strong generic types from the decorated class, enabling:\n *   • typed vault injection (`injectVault<T>()`)\n *   • typed reducers, filters, and merge behaviors\n *   • fully inferred state signatures across the pipeline\n *\n * These metadata keys must remain stable and unique, as they serve\n * as the primary lookup mechanism for FeatureCell configuration.\n */\nexport const VAULT_METADATA_KEYS = {\n  /** Unique FeatureCell identifier assigned by the @FeatureCell decorator. */\n  FEATURE_CELL_KEY: 'vault:feature-cell-key',\n\n  /**\n   * Type anchor used to infer a FeatureCell’s state type (TState).\n   * This exists for TypeScript inference only and has no runtime value.\n   */\n  FEATURE_CELL_STATE: 'vault:feature-cell-state'\n} as const;\n","import { VAULT_METADATA_KEYS } from '../constants/metadata-keys.constant';\n\n/**\n * Decorator factory that marks a class as a FeatureCell with an associated state type.\n *\n * This function produces a class decorator that attaches identifying metadata\n * used to associate a FeatureCell instance with a unique key and a compile-time\n * state type anchor.\n *\n * @param key - Unique identifier assigned to the FeatureCell.\n */\nexport function FeatureCell<TState>(key: string) {\n  /**\n   * Applies FeatureCell metadata to the decorated class.\n   *\n   * This decorator assigns a stable FeatureCell key and a state type anchor\n   * used for compile-time inference without introducing runtime behavior.\n   *\n   * @param target - The class constructor being decorated.\n   */\n  // eslint-disable-next-line\n  return function <T extends new (...args: any[]) => {}>(target: T) {\n    /**\n     * Attaches the unique FeatureCell identifier to the target class.\n     */\n    // eslint-disable-next-line\n    (target as any)[VAULT_METADATA_KEYS.FEATURE_CELL_KEY] = key;\n\n    /**\n     * Attaches a state type anchor to the target class.\n     */\n    // eslint-disable-next-line\n    (target as any)[VAULT_METADATA_KEYS.FEATURE_CELL_STATE] = null as unknown as TState;\n  };\n}\n","// angular/feature-cell-di-tokens.ts\nimport { InjectionToken } from '@angular/core';\nimport { DevMode } from '@sdux-vault/shared';\nimport { FeatureCellShape } from '../shapes/feature-cell.shape';\n\n/**\n * Internal registry mapping FeatureCell keys to Angular injection tokens.\n *\n * This map ensures a one-to-one association between a FeatureCell key and its\n * corresponding InjectionToken instance.\n */\n// eslint-disable-next-line\nconst featureCellTokens = new Map<string, InjectionToken<FeatureCellShape<any>>>();\n\n/**\n * Tracks whether a FeatureCell token has already been requested for injection.\n *\n * This is used to enforce single-injection constraints in non-development modes.\n */\nconst featureCellTokenRequested = new Map<string, boolean>();\n\n/**\n * Creates or retrieves an Angular InjectionToken for a FeatureCell.\n *\n * This function enforces uniqueness rules for FeatureCell keys and controls\n * whether a token is being created or retrieved based on the `isCreate` flag.\n *\n * @param key - The unique FeatureCell key.\n * @param isCreate - Whether the token is being created or retrieved.\n * @returns The Angular InjectionToken associated with the FeatureCell.\n */\nfunction internalAngularFeatureCellToken<T>(key: string, isCreate: boolean): InjectionToken<FeatureCellShape<T>> {\n  let token = featureCellTokens.get(key);\n\n  if (isCreate) {\n    if (featureCellTokens.has(key)) {\n      if (!DevMode.active) {\n        throw new Error(\n          `[vault] Duplicate FeatureCell key detected: \"${key}\". ` +\n            `Each FeatureCell must have a unique key. Existing token: \"${key}\"`\n        );\n      }\n\n      return featureCellTokens.get(key)!;\n    }\n\n    token = new InjectionToken<FeatureCellShape<T>>(`FEATURE_CELL:${key}`);\n    featureCellTokens.set(key, token);\n    return token as InjectionToken<FeatureCellShape<T>>;\n  } else {\n    if (!featureCellTokens.has(key)) {\n      throw new Error(\n        `[vault] FeatureCell token not found for key \"${key}\". You must call provideFeatureCell() before retrieving this FeatureCell.`\n      );\n    }\n\n    if (featureCellTokenRequested.has(key)) {\n      if (!DevMode.active) {\n        throw new Error(\n          `[vault] FeatureCell \"${key}\" can only be injected into a single decorated @FeatureCell service.`\n        );\n      }\n\n      return featureCellTokens.get(key)! as InjectionToken<FeatureCellShape<T>>;\n    }\n\n    featureCellTokenRequested.set(key, true);\n    return featureCellTokens.get(key)! as InjectionToken<FeatureCellShape<T>>;\n  }\n}\n\n/**\n * Creates and registers an Angular InjectionToken for a FeatureCell key.\n *\n * @param key - The unique FeatureCell key.\n * @returns The created InjectionToken.\n */\nexport function createAngularFeatureCellToken<T>(key: string) {\n  return internalAngularFeatureCellToken<T>(key, true);\n}\n\n/**\n * Retrieves an existing Angular InjectionToken for a FeatureCell key.\n *\n * @param key - The unique FeatureCell key.\n * @returns The existing InjectionToken.\n */\nexport function getAngularFeatureCellToken<T>(key: string) {\n  return internalAngularFeatureCellToken<T>(key, false);\n}\n\n/**\n * Resets all FeatureCell token state for development or test isolation.\n *\n * This function clears internal token registries and is only active when\n * development mode is enabled.\n */\nexport function resetAngularFeatureCellTokenDevMode(): void {\n  if (!DevMode.active) return;\n\n  featureCellTokens.clear();\n  featureCellTokenRequested.clear();\n}\n","import { inject } from '@angular/core';\nimport { VAULT_METADATA_KEYS } from '../constants/metadata-keys.constant';\nimport { FeatureCellShape } from '../shapes/feature-cell.shape';\nimport { getAngularFeatureCellToken } from '../tokens/feature-cell-di.token';\n\n/**\n * injectVault\n * @function injectVault\n * @description\n * Retrieves the strongly-typed vault instance associated with a\n * `@FeatureCell()`-decorated class. This function must be called **inside**\n * the constructor (or instance initializer) of a FeatureCell service.\n *\n * This version uses static metadata written by the FeatureCell decorator:\n *\n *   target[FEATURE_CELL_KEY] = \"myCell\"\n *   target[FEATURE_CELL_STATE] = null as TState\n *\n * No Reflect metadata is required.\n *\n * @typeParam T - The typed state stored in this FeatureCell.\n *\n * @param featureCellClass - The decorated class whose vault should be injected.\n */\nexport function injectVault<T>(\n  // eslint-disable-next-line\n  featureCellClass?: abstract new (...args: any[]) => object\n): FeatureCellShape<T> {\n  /**\n   * The target\n   */\n  const target = featureCellClass;\n\n  if (!target) {\n    throw new Error(\n      `injectVault() must be called inside a @FeatureCell()-decorated service and must be given the class reference.`\n    );\n  }\n\n  /**\n   * Read static metadata created by the FeatureCell decorator\n   */\n  // eslint-disable-next-line\n  const key = (target as any)[VAULT_METADATA_KEYS.FEATURE_CELL_KEY];\n\n  if (!key) {\n    throw new Error(`injectVault() must be called inside a @FeatureCell()-decorated service.`);\n  }\n\n  /**\n   *  Resolve DI token for this FeatureCell\n   */\n  const token = getAngularFeatureCellToken(key);\n\n  /**\n   *  Inject the vault instance\n   */\n  return inject(token) as FeatureCellShape<T>;\n}\n","import { computed, DestroyRef, inject, signal } from '@angular/core';\nimport { FeatureCellBaseShape, PipelineValue, StateEmitSnapshotShape, VaultErrorShape } from '@sdux-vault/shared';\nimport { Subscription } from 'rxjs';\nimport { FeatureCellShape } from '../../shapes/feature-cell.shape';\n\n/**\n * Angular adapter that augments a core FeatureCell with Angular Signal-based state access.\n *\n * This class bridges a framework-agnostic FeatureCellBaseShape into an Angular-friendly\n * representation by subscribing to state emissions and exposing derived, read-only\n * Angular Signals for value, loading state, error state, and value presence.\n */\nexport class AngularFeatureCellAdapter<T> {\n  /**\n   * Manages internal subscriptions to the core FeatureCell state stream.\n   */\n  readonly #subscriptions = new Subscription();\n\n  /**\n   * Signal representing the current pipeline value.\n   */\n  readonly #value = signal<PipelineValue<T>>(undefined);\n\n  /**\n   * Signal representing the current error state.\n   */\n  readonly #error = signal<VaultErrorShape | null>(null);\n\n  /**\n   * Signal representing whether the FeatureCell is currently loading.\n   */\n  readonly #isLoading = signal(false);\n\n  /**\n   * Computed signal indicating whether a non-null, non-undefined value is present.\n   */\n  readonly #hasValue = computed(() => {\n    const value = this.#value();\n    return value !== null && value !== undefined;\n  });\n\n  /**\n   * Angular destroy reference used to coordinate lifecycle teardown.\n   */\n  readonly #destroyRef = inject(DestroyRef);\n\n  /**\n   * Creates a new AngularFeatureCellAdapter for the provided core FeatureCell.\n   *\n   * @param core - The framework-agnostic FeatureCell instance to adapt.\n   */\n  constructor(private readonly core: FeatureCellBaseShape<T>) {\n    this.#subscriptions.add(\n      this.core.state$.subscribe((stateEmitSnapshot: StateEmitSnapshotShape<T>) => {\n        this.#isLoading.set(stateEmitSnapshot?.snapshot?.isLoading ?? false);\n        this.#error.set(stateEmitSnapshot?.snapshot?.error ?? null);\n        this.#value.set(stateEmitSnapshot?.snapshot?.value ?? undefined);\n      })\n    );\n\n    this.#destroyRef.onDestroy(() => this.destroy());\n  }\n\n  /**\n   * Builds and returns the Angular-augmented FeatureCell instance.\n   *\n   * @returns The FeatureCell with an attached Angular Signal-based state property.\n   */\n  build(): FeatureCellShape<T> {\n    const cell = this.core as FeatureCellShape<T>;\n\n    Object.defineProperty(cell, 'state', {\n      configurable: true,\n      enumerable: true,\n      get: () => ({\n        isLoading: this.#isLoading.asReadonly(),\n        value: this.#value.asReadonly(),\n        error: this.#error.asReadonly(),\n        hasValue: this.#hasValue\n      })\n    });\n\n    return cell;\n  }\n\n  /**\n   * Destroys the adapter by tearing down subscriptions and delegating to the core FeatureCell.\n   *\n   * @returns void\n   */\n  destroy(): void {\n    this.core.destroy();\n    this.#subscriptions.unsubscribe();\n  }\n}\n","import { Provider, Type } from '@angular/core';\nimport { FeatureCell } from '@sdux-vault/core';\nimport { FeatureCellConfig } from '@sdux-vault/engine';\nimport { BehaviorClassContract, ControllerClassContract } from '@sdux-vault/shared';\nimport { createAngularFeatureCellToken } from '../../tokens/feature-cell-di.token';\nimport { AngularFeatureCellAdapter } from './feature.cell.adapter';\n\n/**\n * Angular provider factory that registers and exposes a FeatureCell instance.\n *\n * This function creates the dependency injection providers required to construct\n * a FeatureCell, adapt it for Angular-specific consumption, and register it for\n * global access using the provided configuration.\n *\n * @param service - Angular service type associated with the FeatureCell.\n * @param descriptor - Configuration object defining the FeatureCell contract.\n * @param behaviors - Optional list of behavior classes applied to the FeatureCell.\n * @param controllers - Optional list of controller classes applied to the FeatureCell.\n * @returns An array of Angular providers that supply the configured FeatureCell.\n */\nexport function provideFeatureCell<Service, T>(\n  service: Type<Service>,\n  descriptor: FeatureCellConfig<T>,\n  behaviors: BehaviorClassContract<T>[] = [],\n  controllers: ControllerClassContract<T>[] = []\n): Provider[] {\n  const angularToken = createAngularFeatureCellToken(descriptor.key);\n\n  return [\n    {\n      provide: angularToken,\n      useFactory: () => {\n        const coreCell = FeatureCell(descriptor, behaviors, controllers);\n\n        return new AngularFeatureCellAdapter(coreCell).build();\n      }\n    },\n\n    service\n  ];\n}\n","import { EnvironmentProviders, provideAppInitializer } from '@angular/core';\nimport { VaultCore } from '@sdux-vault/engine';\nimport { VaultConfig } from '@sdux-vault/shared';\n\n/**\n * Registers and initializes the SDuX Vault core within an Angular application.\n *\n * This function sets up the global FeatureCell registry and returns Angular\n * environment providers that ensure Vault core initialization occurs during\n * application bootstrap using the supplied configuration.\n *\n * @param config - Optional Vault configuration used to initialize core services.\n * @returns Angular environment providers that perform Vault initialization at app startup.\n */\nexport function provideVault(config: VaultConfig = {}): EnvironmentProviders {\n  return provideAppInitializer(() => {\n    VaultCore(config);\n  });\n}\n","import { EnvironmentProviders } from '@angular/core';\nimport { resetVaultForTests } from '@sdux-vault/engine';\nimport { DevMode, VaultConfig } from '@sdux-vault/shared';\nimport { provideVault } from '../lib/providers/vault/provide-vault.provider';\n\nexport function provideVaultTesting(config?: VaultConfig): EnvironmentProviders {\n  const finalConfig: VaultConfig = {\n    devMode: true,\n    logLevel: 'off',\n    ...config // overrides defaults\n  };\n\n  if (finalConfig?.devMode) {\n    DevMode.setDevMode(true);\n\n    resetVaultForTests();\n  }\n\n  return provideVault(finalConfig);\n}\n","// --- AI Model File Path (DO NOT DELETE) ---\n// FilePath: libs > angular > src > lib > version > version.register.ts\n// Updated: 2026-03-03 08:06\n//\t Generated by pathcomment [tab] (see .vscode/typescript.code-snippets) or\n//\t cmd+alt+j (see .vscode/keybindings.json)\n// --- END AI MODEL FILE PATH ---\n\nimport { registerVersion } from '@sdux-vault/shared';\n\nconst SDUX_PACKAGE = '@sdux-vault/core-extensions-angular';\nconst SDUX_VERSION = '0.0.4';\n\nregisterVersion(SDUX_PACKAGE, SDUX_VERSION);\n","/*\n * Public API Surface of angular\n */\n\nexport { FeatureCell } from './lib/decorators/feature-cell.decorator';\nexport { injectVault } from './lib/injectors/feature-vault.injector';\nexport { provideFeatureCell } from './lib/providers/feature-cell/provide-feature-cell.provider';\nexport { provideVault } from './lib/providers/vault/provide-vault.provider';\nexport type { VaultSignalStateRef } from './lib/references/vault-signal.reference';\nexport type { FeatureCellShape } from './lib/shapes/feature-cell.shape';\nexport { resetAngularFeatureCellTokenDevMode } from './lib/tokens/feature-cell-di.token';\nexport { provideVaultTesting } from './testing/provide-vault-testing';\nimport './lib/version/version.register';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["FeatureCell"],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,mBAAmB,GAAG;;AAEjC,IAAA,gBAAgB,EAAE,wBAAwB;AAE1C;;;AAGG;AACH,IAAA,kBAAkB,EAAE;CACZ;;AC9BV;;;;;;;;AAQG;AACG,SAAU,WAAW,CAAS,GAAW,EAAA;AAC7C;;;;;;;AAOG;;AAEH,IAAA,OAAO,UAAgD,MAAS,EAAA;AAC9D;;AAEG;;AAEF,QAAA,MAAc,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,GAAG,GAAG;AAE3D;;AAEG;;AAEF,QAAA,MAAc,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,IAAyB;AACrF,IAAA,CAAC;AACH;;AClCA;AAKA;;;;;AAKG;AACH;AACA,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAiD;AAElF;;;;AAIG;AACH,MAAM,yBAAyB,GAAG,IAAI,GAAG,EAAmB;AAE5D;;;;;;;;;AASG;AACH,SAAS,+BAA+B,CAAI,GAAW,EAAE,QAAiB,EAAA;IACxE,IAAI,KAAK,GAAG,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC;IAEtC,IAAI,QAAQ,EAAE;AACZ,QAAA,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AAC9B,YAAA,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACnB,gBAAA,MAAM,IAAI,KAAK,CACb,CAAA,6CAAA,EAAgD,GAAG,CAAA,GAAA,CAAK;oBACtD,CAAA,0DAAA,EAA6D,GAAG,CAAA,CAAA,CAAG,CACtE;YACH;AAEA,YAAA,OAAO,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAE;QACpC;QAEA,KAAK,GAAG,IAAI,cAAc,CAAsB,gBAAgB,GAAG,CAAA,CAAE,CAAC;AACtE,QAAA,iBAAiB,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;AACjC,QAAA,OAAO,KAA4C;IACrD;SAAO;QACL,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AAC/B,YAAA,MAAM,IAAI,KAAK,CACb,gDAAgD,GAAG,CAAA,yEAAA,CAA2E,CAC/H;QACH;AAEA,QAAA,IAAI,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACtC,YAAA,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACnB,gBAAA,MAAM,IAAI,KAAK,CACb,wBAAwB,GAAG,CAAA,oEAAA,CAAsE,CAClG;YACH;AAEA,YAAA,OAAO,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAyC;QAC3E;AAEA,QAAA,yBAAyB,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC;AACxC,QAAA,OAAO,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAyC;IAC3E;AACF;AAEA;;;;;AAKG;AACG,SAAU,6BAA6B,CAAI,GAAW,EAAA;AAC1D,IAAA,OAAO,+BAA+B,CAAI,GAAG,EAAE,IAAI,CAAC;AACtD;AAEA;;;;;AAKG;AACG,SAAU,0BAA0B,CAAI,GAAW,EAAA;AACvD,IAAA,OAAO,+BAA+B,CAAI,GAAG,EAAE,KAAK,CAAC;AACvD;AAEA;;;;;AAKG;SACa,mCAAmC,GAAA;IACjD,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE;IAErB,iBAAiB,CAAC,KAAK,EAAE;IACzB,yBAAyB,CAAC,KAAK,EAAE;AACnC;;ACjGA;;;;;;;;;;;;;;;;;;AAkBG;SACa,WAAW;AACzB;AACA,gBAA0D,EAAA;AAE1D;;AAEG;IACH,MAAM,MAAM,GAAG,gBAAgB;IAE/B,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,MAAM,IAAI,KAAK,CACb,CAAA,6GAAA,CAA+G,CAChH;IACH;AAEA;;AAEG;;IAEH,MAAM,GAAG,GAAI,MAAc,CAAC,mBAAmB,CAAC,gBAAgB,CAAC;IAEjE,IAAI,CAAC,GAAG,EAAE;AACR,QAAA,MAAM,IAAI,KAAK,CAAC,CAAA,uEAAA,CAAyE,CAAC;IAC5F;AAEA;;AAEG;AACH,IAAA,MAAM,KAAK,GAAG,0BAA0B,CAAC,GAAG,CAAC;AAE7C;;AAEG;AACH,IAAA,OAAO,MAAM,CAAC,KAAK,CAAwB;AAC7C;;ACrDA;;;;;;AAMG;MACU,yBAAyB,CAAA;AAuCP,IAAA,IAAA;AAtC7B;;AAEG;AACM,IAAA,cAAc,GAAG,IAAI,YAAY,EAAE;AAE5C;;AAEG;AACM,IAAA,MAAM,GAAG,MAAM,CAAmB,SAAS,6EAAC;AAErD;;AAEG;AACM,IAAA,MAAM,GAAG,MAAM,CAAyB,IAAI,6EAAC;AAEtD;;AAEG;AACM,IAAA,UAAU,GAAG,MAAM,CAAC,KAAK,iFAAC;AAEnC;;AAEG;AACM,IAAA,SAAS,GAAG,QAAQ,CAAC,MAAK;AACjC,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE;AAC3B,QAAA,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;AAC9C,IAAA,CAAC,gFAAC;AAEF;;AAEG;AACM,IAAA,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC;AAEzC;;;;AAIG;AACH,IAAA,WAAA,CAA6B,IAA6B,EAAA;QAA7B,IAAA,CAAA,IAAI,GAAJ,IAAI;AAC/B,QAAA,IAAI,CAAC,cAAc,CAAC,GAAG,CACrB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,iBAA4C,KAAI;AAC1E,YAAA,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,iBAAiB,EAAE,QAAQ,EAAE,SAAS,IAAI,KAAK,CAAC;AACpE,YAAA,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,iBAAiB,EAAE,QAAQ,EAAE,KAAK,IAAI,IAAI,CAAC;AAC3D,YAAA,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,iBAAiB,EAAE,QAAQ,EAAE,KAAK,IAAI,SAAS,CAAC;QAClE,CAAC,CAAC,CACH;AAED,QAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;IAClD;AAEA;;;;AAIG;IACH,KAAK,GAAA;AACH,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,IAA2B;AAE7C,QAAA,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE;AACnC,YAAA,YAAY,EAAE,IAAI;AAClB,YAAA,UAAU,EAAE,IAAI;AAChB,YAAA,GAAG,EAAE,OAAO;AACV,gBAAA,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE;AACvC,gBAAA,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;AAC/B,gBAAA,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;gBAC/B,QAAQ,EAAE,IAAI,CAAC;aAChB;AACF,SAAA,CAAC;AAEF,QAAA,OAAO,IAAI;IACb;AAEA;;;;AAIG;IACH,OAAO,GAAA;AACL,QAAA,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;AACnB,QAAA,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE;IACnC;AACD;;ACvFD;;;;;;;;;;;;AAYG;AACG,SAAU,kBAAkB,CAChC,OAAsB,EACtB,UAAgC,EAChC,SAAA,GAAwC,EAAE,EAC1C,WAAA,GAA4C,EAAE,EAAA;IAE9C,MAAM,YAAY,GAAG,6BAA6B,CAAC,UAAU,CAAC,GAAG,CAAC;IAElE,OAAO;AACL,QAAA;AACE,YAAA,OAAO,EAAE,YAAY;YACrB,UAAU,EAAE,MAAK;gBACf,MAAM,QAAQ,GAAGA,aAAW,CAAC,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC;gBAEhE,OAAO,IAAI,yBAAyB,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE;YACxD;AACD,SAAA;QAED;KACD;AACH;;ACpCA;;;;;;;;;AASG;AACG,SAAU,YAAY,CAAC,MAAA,GAAsB,EAAE,EAAA;IACnD,OAAO,qBAAqB,CAAC,MAAK;QAChC,SAAS,CAAC,MAAM,CAAC;AACnB,IAAA,CAAC,CAAC;AACJ;;ACbM,SAAU,mBAAmB,CAAC,MAAoB,EAAA;AACtD,IAAA,MAAM,WAAW,GAAgB;AAC/B,QAAA,OAAO,EAAE,IAAI;AACb,QAAA,QAAQ,EAAE,KAAK;QACf,GAAG,MAAM;KACV;AAED,IAAA,IAAI,WAAW,EAAE,OAAO,EAAE;AACxB,QAAA,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC;AAExB,QAAA,kBAAkB,EAAE;IACtB;AAEA,IAAA,OAAO,YAAY,CAAC,WAAW,CAAC;AAClC;;ACnBA;AACA;AACA;AACA;AACA;AACA;AAIA,MAAM,YAAY,GAAG,qCAAqC;AAC1D,MAAM,YAAY,GAAG,OAAO;AAE5B,eAAe,CAAC,YAAY,EAAE,YAAY,CAAC;;ACZ3C;;AAEG;;ACFH;;AAEG;;;;"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@sdux-vault/core-extensions-angular",
+  "version": "0.0.4",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sdux-vault/core.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://www.sdux-vault.com",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@angular/core": "^21.0.0",
+    "@sdux-vault/core": "^0.0.9",
+    "@sdux-vault/engine": "^0.0.9",
+    "@sdux-vault/shared": ">=0.0.6 <0.1.0",
+    "rxjs": "^7.0.0"
+  },
+  "files": [
+    "fesm2022/",
+    "types/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "types": "./types/sdux-vault-core-extensions-angular.d.ts",
+  "main": "./fesm2022/sdux-vault-core-extensions-angular.mjs",
+  "sideEffects": [
+    "./fesm2022/*.mjs",
+    "src/lib/version/version.register.ts"
+  ],
+  "module": "fesm2022/sdux-vault-core-extensions-angular.mjs",
+  "typings": "types/sdux-vault-core-extensions-angular.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/sdux-vault-core-extensions-angular.d.ts",
+      "default": "./fesm2022/sdux-vault-core-extensions-angular.mjs"
+    }
+  }
+}

package/types/sdux-vault-core-extensions-angular.d.ts

@@ -0,0 +1,115 @@
+import { PipelineValue, VaultErrorShape, FeatureCellBaseShape, BehaviorClassContract, ControllerClassContract, VaultConfig } from '@sdux-vault/shared';
+import { Signal, Type, Provider, EnvironmentProviders } from '@angular/core';
+import { FeatureCellConfig } from '@sdux-vault/engine';
+
+/**
+ * Decorator factory that marks a class as a FeatureCell with an associated state type.
+ *
+ * This function produces a class decorator that attaches identifying metadata
+ * used to associate a FeatureCell instance with a unique key and a compile-time
+ * state type anchor.
+ *
+ * @param key - Unique identifier assigned to the FeatureCell.
+ */
+declare function FeatureCell<TState>(key: string): <T extends new (...args: any[]) => {}>(target: T) => void;
+
+/**
+ * Reactive signal-based view of a FeatureCell’s current state.
+ *
+ * This interface defines the set of Angular signals exposed for observing
+ * loading status, resolved value, error state, and value presence for a
+ * FeatureCell.
+ */
+interface VaultSignalStateRef<T> {
+    /**
+     * Indicates whether the FeatureCell is currently processing a pipeline operation.
+     */
+    isLoading: Signal<boolean>;
+    /**
+     * Holds the resolved pipeline value or undefined when no value is present.
+     */
+    value: Signal<PipelineValue<T>>;
+    /**
+     * Holds the most recent error emitted by the pipeline or null when no error exists.
+     */
+    error: Signal<VaultErrorShape | null>;
+    /**
+     * Indicates whether the FeatureCell currently holds a non-null resolved value.
+     */
+    hasValue: Signal<boolean>;
+}
+
+/**
+ * Angular-augmented FeatureCell shape that exposes reactive signal-based state.
+ *
+ * This interface extends the core FeatureCellBaseShape by adding a `state`
+ * property that provides signal references for loading, value, error, and
+ * derived state visibility.
+ */
+interface FeatureCellShape<T> extends FeatureCellBaseShape<T> {
+    /**
+     * Reactive signal-based reference to the FeatureCell's resolved state.
+     */
+    state: VaultSignalStateRef<T>;
+}
+
+/**
+ * injectVault
+ * @function injectVault
+ * @description
+ * Retrieves the strongly-typed vault instance associated with a
+ * `@FeatureCell()`-decorated class. This function must be called **inside**
+ * the constructor (or instance initializer) of a FeatureCell service.
+ *
+ * This version uses static metadata written by the FeatureCell decorator:
+ *
+ *   target[FEATURE_CELL_KEY] = "myCell"
+ *   target[FEATURE_CELL_STATE] = null as TState
+ *
+ * No Reflect metadata is required.
+ *
+ * @typeParam T - The typed state stored in this FeatureCell.
+ *
+ * @param featureCellClass - The decorated class whose vault should be injected.
+ */
+declare function injectVault<T>(featureCellClass?: abstract new (...args: any[]) => object): FeatureCellShape<T>;
+
+/**
+ * Angular provider factory that registers and exposes a FeatureCell instance.
+ *
+ * This function creates the dependency injection providers required to construct
+ * a FeatureCell, adapt it for Angular-specific consumption, and register it for
+ * global access using the provided configuration.
+ *
+ * @param service - Angular service type associated with the FeatureCell.
+ * @param descriptor - Configuration object defining the FeatureCell contract.
+ * @param behaviors - Optional list of behavior classes applied to the FeatureCell.
+ * @param controllers - Optional list of controller classes applied to the FeatureCell.
+ * @returns An array of Angular providers that supply the configured FeatureCell.
+ */
+declare function provideFeatureCell<Service, T>(service: Type<Service>, descriptor: FeatureCellConfig<T>, behaviors?: BehaviorClassContract<T>[], controllers?: ControllerClassContract<T>[]): Provider[];
+
+/**
+ * Registers and initializes the SDuX Vault core within an Angular application.
+ *
+ * This function sets up the global FeatureCell registry and returns Angular
+ * environment providers that ensure Vault core initialization occurs during
+ * application bootstrap using the supplied configuration.
+ *
+ * @param config - Optional Vault configuration used to initialize core services.
+ * @returns Angular environment providers that perform Vault initialization at app startup.
+ */
+declare function provideVault(config?: VaultConfig): EnvironmentProviders;
+
+/**
+ * Resets all FeatureCell token state for development or test isolation.
+ *
+ * This function clears internal token registries and is only active when
+ * development mode is enabled.
+ */
+declare function resetAngularFeatureCellTokenDevMode(): void;
+
+declare function provideVaultTesting(config?: VaultConfig): EnvironmentProviders;
+
+export { FeatureCell, injectVault, provideFeatureCell, provideVault, provideVaultTesting, resetAngularFeatureCellTokenDevMode };
+export type { FeatureCellShape, VaultSignalStateRef };