@kosdev-code/kos-ui-plugin 2.1.17 → 2.1.19

package/lib/utils/reactive-extension-registry.d.ts

@@ -0,0 +1,140 @@
+import { PluginExtension, PluginExtensionsType } from '../../types/plugins';
+
+/**
+ * Event emitted when extension point changes
+ */
+export interface ExtensionPointChangeEvent {
+    extensionPoint: string;
+    changeType: "contribution-enabled" | "contribution-disabled" | "best-changed";
+    affectedContribution: string;
+    newBest?: string;
+    timestamp: number;
+}
+/**
+ * Reactive extension registry that monitors contribution state
+ *
+ * Bridges the gap between ContributionRegistry (state management) and
+ * React components by providing filtered extension lists and change notifications.
+ *
+ * This registry:
+ * - Filters extensions based on enabled state
+ * - Subscribes to ContributionRegistry for state changes
+ * - Emits ExtensionPointChangeEvent when contributions change
+ * - Manages extension point-scoped subscriptions
+ * - Handles cleanup to prevent memory leaks
+ *
+ * @example
+ * ```typescript
+ * const registry = new ReactiveExtensionRegistry(extensions);
+ *
+ * // Get only enabled extensions
+ * const enabledExtensions = registry.getExtensions('ddk.settings.view');
+ *
+ * // Subscribe to changes
+ * const unsubscribe = registry.subscribe('ddk.settings.view', (event) => {
+ *   console.log('Extension point changed:', event);
+ * });
+ *
+ * // Cleanup when done
+ * registry.destroy();
+ * ```
+ */
+export declare class ReactiveExtensionRegistry {
+    /**
+     * Reference to all plugin extensions (unfiltered)
+     */
+    private extensions;
+    /**
+     * Map of extension point to listeners
+     * Each extension point can have multiple components listening for changes
+     */
+    private listeners;
+    /**
+     * Unsubscribe function for ContributionRegistry subscription
+     * Used during cleanup to remove listener
+     */
+    private contributionUnsubscribe;
+    constructor(extensions: PluginExtensionsType);
+    /**
+     * Get extensions for an extension point (filtered by enabled state)
+     *
+     * By default, only returns enabled contributions. Use `includeDisabled: true`
+     * to get all contributions regardless of state.
+     *
+     * @param extensionPoint - Extension point identifier
+     * @param includeDisabled - If true, include disabled contributions (default: false)
+     * @returns Record of extension ID to extension object
+     *
+     * @example
+     * ```typescript
+     * // Get only enabled settings extensions
+     * const enabled = registry.getExtensions('ddk.settings.view');
+     *
+     * // Get all settings extensions (including disabled)
+     * const all = registry.getExtensions('ddk.settings.view', true);
+     * ```
+     */
+    getExtensions(extensionPoint: string, includeDisabled?: boolean): Record<string, PluginExtension>;
+    /**
+     * Subscribe to changes for a specific extension point
+     *
+     * Registers a listener that will be called whenever contributions for
+     * the specified extension point change state (enabled/disabled) or when
+     * the best contribution for that point changes.
+     *
+     * @param extensionPoint - Extension point identifier to monitor
+     * @param listener - Callback function to handle change events
+     * @returns Unsubscribe function to stop receiving events
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = registry.subscribe('ddk.settings.view', (event) => {
+     *   if (event.changeType === 'best-changed') {
+     *     console.log('New best contribution:', event.newBest);
+     *   }
+     * });
+     *
+     * // Later...
+     * unsubscribe();
+     * ```
+     */
+    subscribe(extensionPoint: string, listener: (event: ExtensionPointChangeEvent) => void): () => void;
+    /**
+     * Internal: Subscribe to contribution state changes
+     *
+     * Sets up subscription to ContributionRegistry to receive notifications
+     * when any contribution's enabled state changes. Routes these events to
+     * extension point-specific listeners.
+     *
+     * @private
+     */
+    private subscribeToContributionChanges;
+    /**
+     * Internal: Handle contribution state change
+     *
+     * Called when ContributionRegistry emits a state change event.
+     * Determines if the "best" contribution has changed and emits
+     * ExtensionPointChangeEvent to all listeners for that extension point.
+     *
+     * @param event - Contribution state change event from ContributionRegistry
+     * @private
+     */
+    private handleContributionChange;
+    /**
+     * Cleanup subscriptions and listeners
+     *
+     * Call this when the registry is no longer needed to prevent memory leaks.
+     * Typically called when the PluginsProvider is unmounted.
+     *
+     * @example
+     * ```typescript
+     * useEffect(() => {
+     *   const registry = new ReactiveExtensionRegistry(extensions);
+     *   // Use registry...
+     *   return () => registry.destroy();
+     * }, []);
+     * ```
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=reactive-extension-registry.d.ts.map

package/lib/utils/reactive-extension-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-extension-registry.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-plugin/src/lib/utils/reactive-extension-registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAI7B;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,sBAAsB,GAAG,uBAAuB,GAAG,cAAc,CAAC;IAC9E,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,yBAAyB;IACpC;;OAEG;IACH,OAAO,CAAC,UAAU,CAAuB;IAEzC;;;OAGG;IACH,OAAO,CAAC,SAAS,CAGf;IAEF;;;OAGG;IACH,OAAO,CAAC,uBAAuB,CAA6B;gBAEhD,UAAU,EAAE,oBAAoB;IAM5C;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAAa,CACX,cAAc,EAAE,MAAM,EACtB,eAAe,UAAQ,GACtB,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;IAgBlC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,CACP,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,yBAAyB,KAAK,IAAI,GACnD,MAAM,IAAI;IAuBb;;;;;;;;OAQG;IACH,OAAO,CAAC,8BAA8B;IAMtC;;;;;;;;;OASG;IACH,OAAO,CAAC,wBAAwB;IA6ChC;;;;;;;;;;;;;;OAcG;IACH,OAAO,IAAI,IAAI;CAQhB"}

package/lib/webpack/index.d.ts

@@ -1,2 +1,4 @@
 export * from './with-kos-config';
+export * from './with-plugin-dev-server';
+export * from './with-plugin-dev-aggregator';
 //# sourceMappingURL=index.d.ts.map

package/lib/webpack/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-plugin/src/lib/webpack/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-plugin/src/lib/webpack/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC"}

package/lib/webpack/with-plugin-dev-aggregator.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Multi-Plugin Development Mode Aggregation Middleware
+ *
+ * This webpack composable aggregates metadata from multiple plugin dev servers
+ * running on different ports, combining them into a single response at the
+ * `/api/kos/ui/plugins/contexts` endpoint.
+ *
+ * This allows a host app to load multiple plugins simultaneously during development.
+ */
+export interface PluginDevAggregatorOptions {
+    /**
+     * List of plugin dev server URLs to aggregate.
+     * Example: ['http://localhost:4201', 'http://localhost:4202']
+     */
+    pluginServers: string[];
+    /**
+     * Include the host app's own .kos.json plugin definitions.
+     * Default: true
+     */
+    includeHostPlugins?: boolean;
+    /**
+     * Path to the host app's .kos.json file.
+     * Default: './.kos.json'
+     */
+    kosJsonPath?: string;
+    /**
+     * Merge backend plugins with local dev plugins.
+     * When true, fetches plugins from backend and overlays local dev plugins on top.
+     * Local dev plugins get overrides pointing to dev servers.
+     * Backend plugins use their original URLs (no overrides).
+     *
+     * This is useful for third-party developers who want to:
+     * - Run against a production DDK backend
+     * - Load DDK base plugins from the backend
+     * - Develop their own custom plugins locally
+     *
+     * Default: false (local-only mode)
+     */
+    mergeWithBackend?: boolean;
+    /**
+     * Fallback to backend if no local plugin servers are available.
+     * Default: true
+     */
+    fallbackToBackend?: boolean;
+    /**
+     * Backend URL to fallback to when no plugin servers available.
+     * Default: 'http://localhost:8081'
+     */
+    backendUrl?: string;
+    /**
+     * Enable verbose logging for debugging.
+     * Default: false
+     */
+    verbose?: boolean;
+}
+/**
+ * Webpack plugin composable that aggregates multiple plugin dev servers.
+ *
+ * @example
+ * ```typescript
+ * // Host app webpack.config.ts
+ * import { withPluginDevAggregator } from '@kosdev-code/kos-ui-plugin/webpack';
+ *
+ * export default composePlugins(
+ *   withNx(),
+ *   withReact({}),
+ *   withPluginDevAggregator({
+ *     pluginServers: [
+ *       'http://localhost:4201',  // beverage-pour
+ *       'http://localhost:4202'   // kos-ddk-standard-plugin
+ *     ]
+ *   })
+ * );
+ * ```
+ *
+ * @example With environment variables
+ * ```typescript
+ * const pluginServers = [
+ *   process.env.PLUGIN_A_DEV === 'true' && 'http://localhost:4201',
+ *   process.env.PLUGIN_B_DEV === 'true' && 'http://localhost:4202',
+ * ].filter(Boolean);
+ *
+ * export default composePlugins(
+ *   withNx(),
+ *   withReact({}),
+ *   withPluginDevAggregator({
+ *     pluginServers,
+ *     fallbackToBackend: pluginServers.length === 0
+ *   })
+ * );
+ * ```
+ */
+export declare const withPluginDevAggregator: (options: PluginDevAggregatorOptions) => (config: any, context: any) => any;
+//# sourceMappingURL=with-plugin-dev-aggregator.d.ts.map

package/lib/webpack/with-plugin-dev-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-plugin-dev-aggregator.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-plugin/src/lib/webpack/with-plugin-dev-aggregator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;IAExB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,YACzB,0BAA0B,cAYnB,GAAG,WAAW,GAAG,QA8VlC,CAAC"}

package/lib/webpack/with-plugin-dev-server.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Configuration options for plugin development server middleware
+ */
+export interface PluginDevServerOptions {
+    /**
+     * Path to .kos.json file, relative to project root.
+     * Default: '.kos.json'
+     */
+    kosJsonPath?: string;
+    /**
+     * Project root directory. Used to resolve kosJsonPath.
+     * Default: process.cwd()
+     */
+    projectRoot?: string;
+    /**
+     * Default plugin context if not specified in .kos.json test section.
+     * Default: 'kosdev.ddk'
+     */
+    defaultContext?: string;
+    /**
+     * Enable verbose logging for debugging.
+     * Default: false
+     */
+    verbose?: boolean;
+}
+/**
+ * Webpack plugin composable that adds plugin development server middleware.
+ *
+ * This middleware serves the `/api/kos/ui/plugins/contexts` endpoint, mimicking
+ * the backend KOS plugin API response format. It enables local plugin development
+ * without requiring backend deployment.
+ *
+ * @example
+ * ```typescript
+ * // webpack.config.ts
+ * import { withKosConfig, withPluginDevServer } from '@kosdev-code/kos-ui-plugin/webpack';
+ * import { composePlugins, withNx } from '@nx/webpack';
+ *
+ * export default composePlugins(
+ *   withNx(),
+ *   withReact({}),
+ *   withKosConfig(webpack),
+ *   withPluginDevServer()  // ← Add plugin dev server
+ * );
+ * ```
+ *
+ * @example With options
+ * ```typescript
+ * export default composePlugins(
+ *   withNx(),
+ *   withReact({}),
+ *   withKosConfig(webpack),
+ *   withPluginDevServer({
+ *     kosJsonPath: '.kos.json',
+ *     defaultContext: 'kosdev.ddk',
+ *     verbose: true
+ *   })
+ * );
+ * ```
+ *
+ * ## .kos.json Structure
+ *
+ * The middleware reads two sections from .kos.json:
+ *
+ * ```json
+ * {
+ *   "kos": {
+ *     "ui": {
+ *       "plugin": {
+ *         "id": "MyPlugin",
+ *         "extensions": [...],
+ *         "contributes": {...}
+ *       }
+ *     }
+ *   },
+ *   "test": {
+ *     "plugin": {
+ *       "context": "kosdev.ddk"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * - `kos.ui.plugin`: Production plugin descriptor (becomes API `descriptor`)
+ * - `test.plugin.context`: Development plugin context/group name
+ *
+ * ## Response Format
+ *
+ * The middleware returns the same format as the backend `/api/kos/ui/plugins/contexts`:
+ *
+ * ```json
+ * {
+ *   "status": 200,
+ *   "version": {"major": 1, "minor": 0},
+ *   "data": [
+ *     {
+ *       "name": "kosdev.ddk",
+ *       "plugins": [
+ *         {
+ *           "descriptor": { ... },
+ *           "id": "uuid-v4",
+ *           "path": "/"
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * @param options - Configuration options
+ */
+export declare const withPluginDevServer: (options?: PluginDevServerOptions) => (config: any, context: any) => any;
+//# sourceMappingURL=with-plugin-dev-server.d.ts.map

package/lib/webpack/with-plugin-dev-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-plugin-dev-server.d.ts","sourceRoot":"","sources":["../../../../../../packages/sdk/kos-ui-plugin/src/lib/webpack/with-plugin-dev-server.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AACH,eAAO,MAAM,mBAAmB,aAAa,sBAAsB,cAQjD,GAAG,WAAW,GAAG,QAuJlC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kosdev-code/kos-ui-plugin",
-  "version": "2.1.17",
+  "version": "2.1.19",
   "type": "module",
   "exports": {
     ".": {
@@ -21,7 +21,7 @@
   },
   "kos": {
     "build": {
-      "gitHash": "c98a36c0d6454b4648b4e9d014b0e57fcd1d39a1"
+      "gitHash": "6a8e249e4d22e16b7c678edf286c58258f65b6db"
     }
   },
   "publishConfig": {

package/types/contribution-enablement.d.ts

@@ -0,0 +1,293 @@
+import { BaseContribution, PluginExtensionsType, ProcessedContributions } from './plugins';
+
+/**
+ * Enhanced contribution interface with runtime enablement state
+ *
+ * Extends BaseContribution with fields that enable dynamic runtime control
+ * over contribution visibility and availability. This allows plugins to
+ * respond to events (feature flags, device state, etc.) and update which
+ * contributions are visible to the plugin system.
+ *
+ * @example
+ * ```typescript
+ * const contribution: DynamicContribution = {
+ *   id: 'advanced-settings',
+ *   remote: 'settingsPlugin',
+ *   sectionId: 'settings',
+ *   enabled: true,
+ *   enabledCondition: (context) => {
+ *     return context.context?.userRole === 'admin';
+ *   }
+ * };
+ * ```
+ */
+export interface DynamicContribution extends BaseContribution {
+    /**
+     * Whether this contribution is currently enabled
+     *
+     * When false, the contribution will be filtered out by resolveBestExtension
+     * and will not be visible to DynamicComponent or other plugin consumers.
+     *
+     * @default true
+     */
+    enabled: boolean;
+    /**
+     * Optional reason for disabled state
+     *
+     * Useful for debugging, logging, and displaying to users why a contribution
+     * is unavailable. Should be a human-readable string.
+     *
+     * @example "Feature flag 'advanced-mode' is disabled"
+     * @example "User lacks premium license"
+     * @example "Device mode: basic"
+     */
+    disabledReason?: string;
+    /**
+     * Optional timestamp when enabled state last changed
+     *
+     * Unix timestamp (milliseconds) of the last state transition.
+     * Useful for debugging, auditing, and temporal queries.
+     *
+     * @example Date.now() // 1705780800000
+     */
+    lastStateChange?: number;
+    /**
+     * Optional conditional enablement function
+     *
+     * Evaluated when contribution is accessed via isEnabled().
+     * Allows for dynamic enablement based on runtime context.
+     *
+     * If provided, this function is called in addition to checking the
+     * `enabled` boolean field. Both must be true for the contribution
+     * to be considered enabled.
+     *
+     * @param context - Current runtime context including extensions, contributions, and custom data
+     * @returns true if contribution should be enabled, false otherwise
+     *
+     * @example
+     * ```typescript
+     * enabledCondition: (context) => {
+     *   const licenseModel = context.context?.licenseModel;
+     *   return licenseModel?.hasPremiumLicense === true;
+     * }
+     * ```
+     */
+    enabledCondition?: (context: EnablementContext) => boolean;
+}
+/**
+ * Context provided to enablement condition functions
+ *
+ * Provides runtime information that enablement conditions can use to
+ * determine whether a contribution should be enabled. This includes
+ * the current plugin system state and custom application data.
+ */
+export interface EnablementContext {
+    /**
+     * Current extensions state
+     *
+     * The full PluginExtensionsType object representing all registered
+     * extension points and their contributions.
+     */
+    extensions: PluginExtensionsType;
+    /**
+     * Current contributions state
+     *
+     * Processed contributions including experiences and other contribution types.
+     */
+    contributions: ProcessedContributions;
+    /**
+     * Custom context data
+     *
+     * Application-specific context that can be used in enablement conditions.
+     * For example, user model, license model, device state, etc.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   userModel: { role: 'admin', id: '123' },
+     *   licenseModel: { hasPremiumLicense: true },
+     *   deviceState: { mode: 'advanced' }
+     * }
+     * ```
+     */
+    context?: Record<string, any>;
+}
+/**
+ * Event emitted when a contribution's enabled state changes
+ *
+ * This event is emitted by ContributionRegistry whenever setEnabled()
+ * or batchUpdate() changes a contribution's state. Listeners can subscribe
+ * to these events to react to enablement changes.
+ */
+export interface ContributionStateChangeEvent {
+    /**
+     * Unique identifier of the contribution that changed
+     */
+    contributionId: string;
+    /**
+     * Extension point this contribution belongs to
+     *
+     * @example "ddk.features"
+     * @example "ddk.settings.view"
+     */
+    extensionPoint: string;
+    /**
+     * New enabled state (true = enabled, false = disabled)
+     */
+    enabled: boolean;
+    /**
+     * Previous enabled state before this change
+     */
+    previousState: boolean;
+    /**
+     * Optional reason for the state change
+     *
+     * @example "Feature flag 'advanced-mode' changed to enabled"
+     * @example "App unloaded"
+     */
+    reason?: string;
+    /**
+     * Unix timestamp (milliseconds) when this change occurred
+     */
+    timestamp: number;
+}
+/**
+ * Centralized contribution enablement registry interface
+ *
+ * The ContributionRegistry manages the enabled/disabled state of all
+ * contributions in the plugin system. It provides methods to:
+ * - Update contribution state
+ * - Query contribution state
+ * - Subscribe to state changes
+ * - Perform batch atomic updates
+ *
+ * This is the primary API for implementing dynamic contribution enablement.
+ */
+export interface IContributionRegistry {
+    /**
+     * Set enabled state for a contribution
+     *
+     * Updates the contribution's enabled state and emits a
+     * ContributionStateChangeEvent to all subscribers.
+     *
+     * @param contributionId - Unique identifier of the contribution
+     * @param enabled - New enabled state (true = enabled, false = disabled)
+     * @param reason - Optional human-readable reason for the change
+     *
+     * @throws Error if contribution does not exist
+     *
+     * @example
+     * ```typescript
+     * ContributionRegistry.setEnabled(
+     *   'advanced-settings',
+     *   false,
+     *   'Device mode changed to basic'
+     * );
+     * ```
+     */
+    setEnabled(contributionId: string, enabled: boolean, reason?: string): void;
+    /**
+     * Get enabled state for a contribution
+     *
+     * Checks both the enabled boolean field and evaluates any
+     * enabledCondition function if present. Returns true only if
+     * both checks pass.
+     *
+     * @param contributionId - Unique identifier of the contribution
+     * @returns true if contribution is enabled, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (ContributionRegistry.isEnabled('advanced-settings')) {
+     *   // Show advanced settings UI
+     * }
+     * ```
+     */
+    isEnabled(contributionId: string): boolean;
+    /**
+     * Subscribe to all contribution state changes
+     *
+     * Registers a listener that will be called whenever any contribution's
+     * enabled state changes. The listener receives a ContributionStateChangeEvent.
+     *
+     * @param listener - Callback function to handle state change events
+     * @returns Unsubscribe function to stop receiving events
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = ContributionRegistry.subscribe((event) => {
+     *   console.log(`${event.contributionId} ${event.enabled ? 'enabled' : 'disabled'}`);
+     * });
+     *
+     * // Later: stop listening
+     * unsubscribe();
+     * ```
+     */
+    subscribe(listener: (event: ContributionStateChangeEvent) => void): () => void;
+    /**
+     * Subscribe to changes for a specific extension point
+     *
+     * Like subscribe(), but only emits events for contributions
+     * belonging to the specified extension point.
+     *
+     * @param extensionPoint - Extension point identifier to monitor
+     * @param listener - Callback function to handle state change events
+     * @returns Unsubscribe function to stop receiving events
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = ContributionRegistry.subscribeToExtensionPoint(
+     *   'ddk.settings.view',
+     *   (event) => {
+     *     console.log(`Settings contribution changed: ${event.contributionId}`);
+     *   }
+     * );
+     * ```
+     */
+    subscribeToExtensionPoint(extensionPoint: string, listener: (event: ContributionStateChangeEvent) => void): () => void;
+    /**
+     * Batch update multiple contributions atomically
+     *
+     * Updates multiple contribution states in a single atomic operation.
+     * All updates succeed or all fail together. Emits one event per
+     * contribution that changed state.
+     *
+     * @param updates - Array of contribution updates to apply
+     *
+     * @example
+     * ```typescript
+     * // Disable all advanced features at once
+     * ContributionRegistry.batchUpdate([
+     *   { contributionId: 'advanced-settings', enabled: false, reason: 'Basic mode' },
+     *   { contributionId: 'diagnostics', enabled: false, reason: 'Basic mode' },
+     *   { contributionId: 'dev-tools', enabled: false, reason: 'Basic mode' }
+     * ]);
+     * ```
+     */
+    batchUpdate(updates: Array<{
+        contributionId: string;
+        enabled: boolean;
+        reason?: string;
+    }>): void;
+    /**
+     * Get all contributions for an extension point
+     *
+     * Returns an array of DynamicContribution objects for the specified
+     * extension point. By default, only returns enabled contributions.
+     *
+     * @param extensionPoint - Extension point identifier
+     * @param includeDisabled - If true, include disabled contributions in results
+     * @returns Array of contributions for the extension point
+     *
+     * @example
+     * ```typescript
+     * // Get only enabled settings contributions
+     * const enabledSettings = ContributionRegistry.getContributions('ddk.settings.view');
+     *
+     * // Get all settings contributions (including disabled)
+     * const allSettings = ContributionRegistry.getContributions('ddk.settings.view', true);
+     * ```
+     */
+    getContributions(extensionPoint: string, includeDisabled?: boolean): DynamicContribution[];
+}
+//# sourceMappingURL=contribution-enablement.d.ts.map

package/types/contribution-enablement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contribution-enablement.d.ts","sourceRoot":"","sources":["../../../../../packages/sdk/kos-ui-plugin/src/types/contribution-enablement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D;;;;;;;OAOG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC;CAC5D;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,UAAU,EAAE,oBAAoB,CAAC;IAEjC;;;;OAIG;IACH,aAAa,EAAE,sBAAsB,CAAC;IAEtC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,UAAU,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5E;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC;IAE3C;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CACP,QAAQ,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,IAAI,GACtD,MAAM,IAAI,CAAC;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,yBAAyB,CACvB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,4BAA4B,KAAK,IAAI,GACtD,MAAM,IAAI,CAAC;IAEd;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,CACT,OAAO,EAAE,KAAK,CAAC;QACb,cAAc,EAAE,MAAM,CAAC;QACvB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC,GACD,IAAI,CAAC;IAER;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,CACd,cAAc,EAAE,MAAM,EACtB,eAAe,CAAC,EAAE,OAAO,GACxB,mBAAmB,EAAE,CAAC;CAC1B"}