@supacloud/app 0.5.0 → 0.6.1

package/dist/inject.d.ts

@@ -1,68 +1,29 @@
+import { type InjectOptions } from "@angular/core";
 import type { EnvironmentProviders, Provider, Token } from "./provider";
 import { InjectionToken } from "./token";
-export interface InjectFlags {
-    /** If true, returns undefined instead of throwing when token is not found. */
-    optional?: boolean;
-    /** If true, requires token to be resolved from current local injector. */
-    self?: boolean;
-    /** If true, skips current local injector and resolves from parent. */
-    skipSelf?: boolean;
-    /** If true, resolves from host injector. */
-    host?: boolean;
-}
+export type InjectFlags = InjectOptions;
 export interface InjectorLike {
     get<T>(token: Token<T>, options?: InjectFlags): T | undefined;
+    get<T>(token: Token<T>, notFoundValue: T, options?: InjectFlags): T;
     readonly parent?: InjectorLike;
 }
-/**
- * Returns the current active Injector context, or null if not inside an injection context.
- */
 export declare function getActiveInjector(): InjectorLike | null;
 /**
- * Built-in injection token for resolving the active injector instance.
- * Modeled directly after Angular's INJECTOR token.
+ * Compatibility token backed by Angular's public Injector token.
+ * The compiler does not use this token; it is provided for runtime/TestBed APIs.
  */
 export declare const INJECTOR: InjectionToken<InjectorLike>;
-/**
- * Executes a function within the scope of a specific injector.
- * Modeled directly after Angular's `runInInjectionContext(injector, fn)`.
- */
 export declare function runInInjectionContext<R>(injector: InjectorLike, fn: () => R): R;
 /**
- * Resolves a token from the currently active injection context.
- * Modeled directly after Angular's `inject(token)`.
- *
- * Can be used in:
- * 1. Property initializers of classes
- * 2. Constructors
- * 3. Functional route guards (CanActivateFn)
- * 4. Route resolvers (ResolveFn)
- * 5. Factory providers
- * 6. Code executed inside `runInInjectionContext`
+ * Angular is the source of truth for runtime injection semantics. This
+ * wrapper keeps the SupaCloud error contract for calls outside a context.
  */
 export declare function inject<T>(token: Token<T>, options?: InjectFlags): T;
-/**
- * Injects all instances registered for a multi-provider token.
- * Modeled after Angular's multi-provider injection.
- */
 export declare function injectAll<T>(token: Token<T>): T[];
-/**
- * Creates a hierarchical child injector that inherits providers from a parent injector.
- * Modeled directly after Angular's hierarchical injectors.
- */
 export declare function createChildInjector(parent: InjectorLike, localProviders?: Map<Token<unknown> | string, unknown> | Record<string, unknown>): InjectorLike & {
     readonly parent: InjectorLike;
 };
-/**
- * Asserts that execution is currently within an injection context.
- * Modeled after Angular's `assertInInjectionContext`.
- */
 export declare function assertInInjectionContext(fnName: string): void;
-/**
- * Injects the AbortSignal of the active DestroyRef.
- * Automatically aborted when the active context or service is destroyed.
- * Modeled after Angular's DestroyRef signal pattern.
- */
 export declare function injectDestroySignal(): AbortSignal;
 export interface EnvironmentInjector extends InjectorLike {
     get<T>(token: Token<T>, options?: InjectFlags): T;
@@ -73,9 +34,8 @@ export interface EnvironmentInjector extends InjectorLike {
     readonly parent?: InjectorLike;
 }
 /**
- * Creates an EnvironmentInjector with an isolated dependency scope and lifecycle.
- * Modeled directly after Angular 14+ createEnvironmentInjector.
- * Automatically executes all ENVIRONMENT_INITIALIZER / APP_INITIALIZER hooks upon creation,
- * and executes DestroyRef teardowns and OnDestroy hooks upon destroy().
+ * Runtime compatibility adapter over Angular's public EnvironmentInjector.
+ * SupaCloud EnvironmentProviders are flattened before crossing the boundary;
+ * no Angular private API is referenced.
  */
 export declare function createEnvironmentInjector(providers: Array<Provider | EnvironmentProviders>, parent?: InjectorLike): EnvironmentInjector;

package/dist/provider.d.ts

@@ -7,6 +7,14 @@ export interface Type<T> {
 }
 /** Anything that can identify a provider: an InjectionToken or a class. */
 export type Token<T = any> = InjectionToken<T> | Type<T> | ForwardRefFn<InjectionToken<T> | Type<T>>;
+export interface ProviderDependency {
+    token: Token;
+    optional?: boolean;
+    self?: boolean;
+    skipSelf?: boolean;
+    host?: boolean;
+}
+export type ProviderDep = Token | ProviderDependency;
 interface BaseProvider {
     /** Overrides the scope derived from @Injectable / token defaults. */
     scope?: Scope;
@@ -19,7 +27,7 @@ export interface ClassProvider<T = any> extends BaseProvider {
     provide: Token<T>;
     useClass: Type<T> | ForwardRefFn<Type<T>>;
     /** Explicit dependency tokens, positional (constructor order). */
-    deps?: Token[];
+    deps?: ProviderDep[];
 }
 export interface ValueProvider<T = any> extends BaseProvider {
     provide: Token<T>;
@@ -28,7 +36,7 @@ export interface ValueProvider<T = any> extends BaseProvider {
 export interface FactoryProvider<T = any> extends BaseProvider {
     provide: Token<T>;
     useFactory: (...deps: any[]) => T;
-    deps?: Token[];
+    deps?: ProviderDep[];
 }
 export interface ExistingProvider<T = any> extends BaseProvider {
     provide: Token<T>;
@@ -42,12 +50,15 @@ export declare function isFactoryProvider<T>(provider: Provider<T>): provider is
 export declare function isExistingProvider<T>(provider: Provider<T>): provider is ExistingProvider<T>;
 /**
  * Encapsulates a set of providers created by functional provideXxx APIs.
- * Modeled directly after Angular's EnvironmentProviders.
+ *
+ * This is intentionally a SupaCloud-owned representation. It is converted
+ * to Angular providers at the runtime boundary instead of exposing Angular's
+ * private provider-storage detail as a public contract.
  */
 export interface EnvironmentProviders {
-    ɵproviders: Provider[];
+    readonly providers: Array<Provider | EnvironmentProviders>;
 }
-export declare function makeEnvironmentProviders(providers: Provider[]): EnvironmentProviders;
+export declare function makeEnvironmentProviders(providers: Array<Provider | EnvironmentProviders>): EnvironmentProviders;
 export declare function isEnvironmentProviders(value: unknown): value is EnvironmentProviders;
 export declare function flattenProviders(providers: Array<Provider | EnvironmentProviders>): Provider[];
 /**

package/dist/testing.d.ts

@@ -14,7 +14,6 @@ export declare class TestBed {
     private static declaredProviders;
     private static overriddenProviders;
     private static activeInjector;
-    private static instances;
     /**
      * Configures the testing module with providers and imports.
      */

package/dist/token.d.ts

@@ -1,4 +1,5 @@
 import type { Scope } from "./scope";
+import { InjectionToken as AngularInjectionToken } from "@angular/core";
 export interface InjectionTokenOptions<T> {
     /** Optional default factory used when no explicit provider is registered. */
     factory?: () => T;
@@ -11,7 +12,7 @@ export interface InjectionTokenOptions<T> {
  * Lightweight injection token, modeled after Angular's tree-shakable tokens.
  * Used as a DI key for interfaces and values that are not classes.
  */
-export declare class InjectionToken<T> {
+export declare class InjectionToken<T> extends AngularInjectionToken<T> {
     readonly name: string;
     readonly factory?: () => T;
     readonly providedIn?: "root";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/app",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Angular-style application metadata for SupaCloud: modules, DI tokens, providers, scopes, controllers and commands",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,6 +40,9 @@
     "url": "https://github.com/vibeunion/supacloud.git",
     "directory": "packages/app"
   },
+  "dependencies": {
+    "@angular/core": "^22.1.5"
+  },
   "devDependencies": {
     "@types/bun": "^1.4.0",
     "typescript": "^7.0.2"