// Plugin with NgModule support
export const PluginManifest = {
  name: 'dashboard',
  version: '1.0.0',
  entryComponent: DashboardComponent,
  entryModule: DashboardModule  // NEW: Full NgModule support!
};

// Load multiple plugins in parallel
await pluginManager.loadAndActivateMany([
  { name: 'analytics', container: analyticsContainer },
  { name: 'reports', container: reportsContainer }
]);

// Unload all plugins at once
await pluginManager.unloadAll();

// Filter plugins by metadata
const proPlugins = pluginManager.getPluginsByMetadata({ tier: 'PRO' });

// Load plugin from CDN
await pluginManager.registerRemotePlugin({
  name: 'analytics',
  remoteUrl: 'https://cdn.yourapp.com/plugins/analytics.js',
  exposedModule: 'AnalyticsPlugin'
});

// Hot reload - update plugin without page refresh
await pluginManager.unregisterRemotePlugin('analytics');
await pluginManager.registerRemotePlugin({ /* new version */ });

import { ApplicationConfig } from '@angular/core';
import { providePluginSystem } from '@angular-dynamic/plugin-system';

export const appConfig: ApplicationConfig = {
  providers: [
    providePluginSystem({
      globalTimeout: 30000,
      maxConcurrentLoads: 3,
      enableDevMode: false,
      // v1.1.0: Lifecycle hook timeout protection
      lifecycleHookTimeout: 5000 // Default: 5000ms, set to 0 to disable
    })
  ]
};

import { Component } from '@angular/core';
import { PluginLifecycle, PluginContext } from '@angular-dynamic/plugin-system';

@Component({
  selector: 'invoice-plugin',
  standalone: true,
  template: `<h1>Invoice Plugin</h1>`
})
export class InvoicePluginComponent implements PluginLifecycle {
  async onLoad(context: PluginContext): Promise<void> {
    // Plugin initialization logic
  }

  async onActivate(context: PluginContext): Promise<void> {
    // Called when plugin is rendered
  }

  async onDeactivate(): Promise<void> {
    // Called before plugin is removed
  }

  async onDestroy(): Promise<void> {
    // Cleanup logic
  }
}

export const PluginManifest = {
  name: 'invoice',
  version: '1.0.0',
  entryComponent: InvoicePluginComponent,
  displayName: 'Invoice Plugin',
  description: 'Handles invoice management'
};

import { NgModule, Component, Injectable } from '@angular/core';
import { CommonModule } from '@angular/common';
import { PluginLifecycle, PluginContext } from '@angular-dynamic/plugin-system';

// Plugin-specific service
@Injectable()
export class DashboardService {
  getData() {
    return { visits: 1234, sales: 567 };
  }
}

// Plugin component
@Component({
  selector: 'dashboard-plugin',
  template: `
    <div class="dashboard">
      <h2>Dashboard</h2>
      <p>Visits: {{ data.visits }}</p>
      <p>Sales: {{ data.sales }}</p>
    </div>
  `
})
export class DashboardComponent implements PluginLifecycle {
  data = { visits: 0, sales: 0 };

  constructor(private dashboardService: DashboardService) {}

  async onLoad(context: PluginContext): Promise<void> {
    this.data = this.dashboardService.getData();
  }
}

// Plugin NgModule
@NgModule({
  declarations: [DashboardComponent],
  imports: [CommonModule],
  providers: [DashboardService]
})
export class DashboardModule {}

// Export manifest with entryModule
export const PluginManifest = {
  name: 'dashboard',
  version: '1.0.0',
  entryComponent: DashboardComponent,
  entryModule: DashboardModule  // NgModule with services!
};

import { Component, OnInit } from '@angular/core';
import { PluginManager } from '@angular-dynamic/plugin-system';

@Component({
  selector: 'app-root',
  template: `
    <plugin-outlet [plugin]="'invoice'"></plugin-outlet>
  `,
  standalone: true,
  imports: [PluginOutletComponent]
})
export class AppComponent implements OnInit {
  constructor(private pluginManager: PluginManager) {}

  ngOnInit(): void {
    this.pluginManager.register({
      name: 'invoice',
      loadFn: () => import('./plugins/invoice-plugin'),
      config: {
        autoLoad: true
      }
    });
  }
}

@Injectable({ providedIn: 'root' })
export class PluginManager {
  // Core Methods
  register(config: PluginRegistration): void;
  load(pluginName: string): Promise<PluginMetadata>;
  loadMany(pluginNames: string[]): Promise<PluginMetadata[]>;
  unregister(pluginName: string): Promise<void>;
  getPluginState(pluginName: string): PluginState | undefined;
  isReady(pluginName: string): boolean;

  // v1.2.0: Remote Loading
  registerRemotePlugin(config: RemotePluginConfig): Promise<PluginMetadata>;
  unregisterRemotePlugin(pluginName: string): Promise<void>;
  getRemoteCacheStats(): { size: number; entries: Array<{url: string; loadedAt: Date}> };
  clearRemoteCache(): void;

  // v1.2.0: Helper Methods
  loadAndActivate(pluginName: string, viewContainer: ViewContainerRef): Promise<ComponentRef>;
  loadRemoteAndActivate(config: RemotePluginConfig, viewContainer: ViewContainerRef): Promise<ComponentRef>;

  // v1.3.0: Bulk Operations
  unloadAll(): Promise<void>;
  loadAndActivateMany(plugins: Array<{name: string, container: ViewContainerRef}>): Promise<ComponentRef[]>;
  getPluginsByMetadata(filter: Record<string, any>): PluginMetadata[];

  // v1.1.0: Monitoring
  isUnloading(pluginName: string): boolean;
  getPluginInfo(pluginName: string): PluginInfo | undefined;

  // Observables
  readonly pluginState$: Observable<PluginStateEvent>;
}

interface PluginRegistration {
  name: string;
  loadFn: () => Promise<LoadedPluginModule>;
  config?: {
    autoLoad?: boolean;
    retryOnError?: boolean;
    maxRetries?: number;
    timeout?: number;
    allowedServices?: Array<InjectionToken<any> | Type<any>>;
    metadata?: Record<string, any>;
  };
}

interface PluginLifecycle {
  onLoad?(context: PluginContext): void | Promise<void>;
  onActivate?(context: PluginContext): void | Promise<void>;
  onDeactivate?(): void | Promise<void>;
  onDestroy?(): void | Promise<void>;
}

interface PluginContext {
  readonly pluginName: string;
  readonly hostInjector: Injector;
  getService<T>(token: InjectionToken<T> | Type<T>): T | null;
  emit(eventName: string, data?: any): void;
  subscribe(eventName: string, handler: (data: any) => void): () => void;
}

enum PluginState {
  REGISTERED = 'REGISTERED',
  LOADING = 'LOADING',
  LOADED = 'LOADED',
  ACTIVE = 'ACTIVE',
  ERROR = 'ERROR',
  UNLOADING = 'UNLOADING',
  UNLOADED = 'UNLOADED'
}

pluginManager.register({
  name: 'invoice',
  loadFn: () => import('./plugins/invoice-plugin'),
  config: {
    allowedServices: [HttpClient, Router]
  }
});

providePluginSystem({
  lifecycleHooks: {
    beforeLoad: async (pluginName) => {
      // Pre-load logic
    },
    afterLoad: async (pluginName) => {
      // Post-load logic
    },
    onError: (pluginName, error) => {
      // Error handling
    }
  }
})

providePluginSystem({
  enableDevMode: true,
  debugOptions: {
    logLifecycleHooks: true,      // Log hook calls and timing
    logStateTransitions: true,     // Log state changes
    validateManifests: true,       // Strict manifest validation
    throwOnWarnings: false         // Treat warnings as errors
  },
  lifecycleHookTimeout: 10000     // Custom timeout (default: 5000ms)
})

// Get detailed plugin information
const info = pluginManager.getPluginInfo('invoice');
if (info) {
  console.log(`State: ${info.state}`);
  console.log(`Loaded at: ${info.loadedAt}`);
  console.log(`Error count: ${info.errorCount}`);
  if (info.lastError) {
    console.error(`Last error: ${info.lastError.message}`);
  }
}

// Check if plugin is unloading
if (pluginManager.isUnloading('invoice')) {
  console.log('Plugin is currently being unloaded');
}

pluginManager.pluginState$.subscribe(event => {
  console.log(`Plugin ${event.pluginName} is now ${event.state}`);
});

await pluginManager.loadMany(['invoice', 'reports', 'analytics']);

try {
  await pluginManager.load('invoice');
} catch (error) {
  if (error instanceof PluginLoadError) {
    // Handle load failure
  }
}

// Example: Plugin with long initialization
providePluginSystem({
  lifecycleHookTimeout: 15000 // 15 seconds for data-intensive plugins
})