@limetech/lime-web-components 6.4.0 → 6.5.0

package/dist/core/context.d.ts

@@ -1,19 +1,109 @@
 /**
- * Interface for the context in which the Lime Web Component appears
+ * Describes the context in which a Lime Web Component is running.
+ *
+ * The context provides information about the current business object (limetype and ID)
+ * that the component is associated with. This allows components to load and interact
+ * with the relevant data based on where they are displayed in the application.
+ *
+ * Contexts can be nested when components are embedded within other components,
+ * allowing for hierarchical relationships between different views.
+ *
+ * @example
+ * ```typescript
+ * // Component running in a customer detail view
+ * const context: LimeWebComponentContext = {
+ *     limetype: 'customer',
+ *     id: 12345
+ * };
+ *
+ * // Component on a list view (no specific record)
+ * const listContext: LimeWebComponentContext = {
+ *     limetype: 'customer',
+ *     id: null
+ * };
+ *
+ * // Nested context - contact list within a customer view
+ * const nestedContext: LimeWebComponentContext = {
+ *     limetype: 'contact',
+ *     id: null,
+ *     parent: {
+ *         limetype: 'customer',
+ *         id: 12345
+ *     }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Load related data based on parent context
+ * const repo = platform.get(PlatformServiceName.LimeObjectRepository);
+ *
+ * if (context.parent?.limetype === 'customer' && context.parent.id) {
+ *     const result = await repo.loadObjects('contact', {
+ *         filter: {
+ *             key: 'customer',
+ *             op: '=',
+ *             exp: context.parent.id
+ *         }
+ *     });
+ * }
+ * ```
+ *
  * @public
  * @group Core
  */
 export interface LimeWebComponentContext {
     /**
-     * The name of the limetype of the context
+     * The name of the {@link LimeType} for this context.
+     *
+     * This identifies what type of business object the component is working with
+     * (e.g., 'customer', 'contact', 'deal', 'invoice'). Can be `null` if the
+     * component is not associated with a specific limetype.
+     *
+     * @example
+     * ```typescript
+     * if (context.limetype === 'customer') {
+     *     // Load customer-specific data and features
+     * }
+     * ```
      */
     limetype: string | null;
     /**
-     * The id of the limeobject of the context
+     * The ID of the specific limeobject (record) in this context.
+     *
+     * When set, indicates the component is viewing/editing a specific record.
+     * When `null`, the component may be on a list view or creating a new record.
+     *
+     * @example
+     * ```typescript
+     * if (context.id) {
+     *     // Load and display the specific record
+     *     const object = await repo.loadObject(context.limetype, context.id);
+     * } else {
+     *     // Show list view or new record form
+     * }
+     * ```
      */
     id: number | null;
     /**
-     * Optional parent context, if the current context is nested
+     * Optional parent context when this component is nested within another.
+     *
+     * Used when components are embedded in other components to maintain the
+     * relationship hierarchy. For example, a contact list component shown
+     * within a customer detail view would have the customer as its parent context.
+     *
+     * @example
+     * ```typescript
+     * // Check if running within another context
+     * if (context.parent) {
+     *     console.log(`Nested within ${context.parent.limetype}`);
+     *
+     *     // Load data filtered by parent
+     *     if (context.parent.id) {
+     *         const relatedRecords = await loadRelatedToParent(context.parent);
+     *     }
+     * }
+     * ```
      */
     parent?: LimeWebComponentContext;
 }

package/dist/core/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/core/context.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACpC;;OAEG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB;;OAEG;IACH,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAElB;;OAEG;IACH,MAAM,CAAC,EAAE,uBAAuB,CAAC;CACpC"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/core/context.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,WAAW,uBAAuB;IACpC;;;;;;;;;;;;;OAaG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB;;;;;;;;;;;;;;;OAeG;IACH,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAElB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,EAAE,uBAAuB,CAAC;CACpC"}

package/dist/core/lime-web-component.d.ts

@@ -1,17 +1,73 @@
 import { LimeWebComponentContext } from './context';
 import { LimeWebComponentPlatform } from './platform';
 /**
- * Interface that Lime Web Components must implement
+ * Base interface that all Lime Web Components must implement.
+ *
+ * This interface ensures that every component has access to the {@link LimeWebComponentPlatform}
+ * service container and understands its {@link LimeWebComponentContext} within the application.
+ * In Stencil components, these are injected as properties using the `@Prop` decorator.
+ *
+ * @example
+ * ```typescript
+ * // Access services through platform
+ * const repo = platform.get(PlatformServiceName.LimeObjectRepository);
+ *
+ * // Use context to understand where component is running
+ * console.log(`Running for ${context.limetype} with id ${context.id}`);
+ *
+ * // Load the current object if context has an ID
+ * if (context.id) {
+ *     const limeObject = await repo.loadObject(context.limetype, context.id);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check if running in a nested context
+ * if (context.parent) {
+ *     console.log(`Parent: ${context.parent.limetype}/${context.parent.id}`);
+ *     console.log(`Current: ${context.limetype}`);
+ * }
+ * ```
+ *
+ * @remarks
+ * The platform and context properties are fundamental to component operation:
+ * - `platform` provides access to all services (repositories, HTTP, command bus, etc.)
+ * - `context` describes where the component is running (which limetype, which record)
+ *
  * @public
  * @group Core
  */
 export interface LimeWebComponent {
     /**
-     * Reference to the platform
+     * Reference to the platform service container.
+     *
+     * Use this to access all platform services like repositories, HTTP client,
+     * command bus, navigator, and more. The platform instance is shared across
+     * all components in the same application context.
+     *
+     * @example
+     * ```typescript
+     * const http = platform.get(PlatformServiceName.Http);
+     * const commandBus = platform.get(PlatformServiceName.CommandBus);
+     * ```
      */
     platform: LimeWebComponentPlatform;
     /**
-     * The context this component belongs to
+     * The context describing where this component is running.
+     *
+     * The context provides information about the current limetype and record ID
+     * (if viewing/editing a specific record). Components can use this to load
+     * relevant data and understand their operating environment.
+     *
+     * @example
+     * ```typescript
+     * // Load current record if we have an ID
+     * if (context.id) {
+     *     const repo = platform.get(PlatformServiceName.LimeObjectRepository);
+     *     const object = await repo.loadObject(context.limetype, context.id);
+     * }
+     * ```
      */
     context: LimeWebComponentContext;
 }

package/dist/core/lime-web-component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lime-web-component.d.ts","sourceRoot":"","sources":["../../src/core/lime-web-component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,QAAQ,EAAE,wBAAwB,CAAC;IAEnC;;OAEG;IACH,OAAO,EAAE,uBAAuB,CAAC;CACpC"}
+{"version":3,"file":"lime-web-component.d.ts","sourceRoot":"","sources":["../../src/core/lime-web-component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;;;;;;;;;;;OAYG;IACH,QAAQ,EAAE,wBAAwB,CAAC;IAEnC;;;;;;;;;;;;;;;OAeG;IACH,OAAO,EAAE,uBAAuB,CAAC;CACpC"}

package/dist/core/metadata.d.ts

@@ -1,10 +1,48 @@
 import { Icon } from './icon';
 import { LimeWebComponentPlatform } from './platform';
 /**
- * Metadata for a configured resource
+ * Extensible metadata for registered resources in the Lime CRM platform.
  *
- * A resource can be anything that is registered in the client, e.g.
- * web component or command
+ * This metadata structure is used to describe various resources like web components,
+ * commands, actions, and other extensible elements. It provides a consistent way to
+ * attach human-readable information, icons, tags, and configuration components to
+ * any registered resource.
+ *
+ * Resources that use this metadata include:
+ * - Web components (via WebComponentRegistry)
+ * - Commands (via CommandBus and `@Command` decorator)
+ *
+ * @example
+ * ```typescript
+ * // Register a web component with metadata
+ * registry.register('customer-insights', {
+ *     title: 'Customer Insights',
+ *     description: 'Advanced analytics dashboard for customer behavior',
+ *     icon: 'chart-line',
+ *     tags: ['card-widget', 'start-page'],
+ *     configComponent: {
+ *         name: 'customer-insights-config',
+ *         props: { defaultView: 'monthly' }
+ *     }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Register a command with metadata
+ * @Command({ id: 'export-to-excel' })
+ * class ExportToExcelCommand {
+ *     // Command implementation
+ * }
+ *
+ * // Metadata is provided when registering the command
+ * commandBus.register(ExportToExcelCommand, handler, {
+ *     title: 'Export to Excel',
+ *     description: 'Export selected records to Microsoft Excel',
+ *     icon: { name: 'file-excel', color: 'green' },
+ *     tags: ['bulk-object']
+ * });
+ * ```
  *
  * @see {@link WebComponentRegistry.register | WebComponentRegistry.register}
  * @see {@link CommandBus | CommandBus}
@@ -14,45 +52,107 @@ import { LimeWebComponentPlatform } from './platform';
  */
 export type ConfigMetadata = {
     /**
-     * Human readable name for the resource
+     * Human-readable display name for the resource.
+     *
+     * This should be a concise, user-friendly name that appears in UI elements
+     * like menus, toolbars, and configuration screens.
      */
     title?: string;
     /**
-     * Description of the resource
+     * Detailed description of what the resource does.
+     *
+     * Provide helpful context about the resource's purpose, functionality,
+     * and any important usage notes. This typically appears in tooltips or
+     * help documentation.
      */
     description?: string;
     /**
-     * Icon representing the resource
+     * Icon to visually represent the resource.
+     *
+     * Can be either a string referencing an icon name from the icon library,
+     * or an Icon object with additional properties like color and style.
      */
     icon?: string | Icon;
     /**
-     * List of tags describing the resource. A client may use the tags to
-     * determine if a resource is suitable for a given context
+     * Semantic tags for categorization and context-aware filtering.
+     *
+     * Tags help the platform determine where a component can be placed and when
+     * it is relevant for a given context. These tags typically describe the slot
+     * types or contexts that the component is suited for.
+     *
+     * The available tags are platform-specific and depend on the extensibility
+     * points provided by the host application.
      */
     tags?: string[];
     /**
-     * Component that can be used to configure the given resource
+     * Optional configuration UI component for this resource.
+     *
+     * Specifies a web component that provides a configuration interface for
+     * customizing the resource's behavior. This is typically used in admin
+     * interfaces or setup wizards.
      */
     configComponent?: {
         /**
-         * Tag name of the web component
+         * Tag name of the configuration web component.
+         *
+         * Must be a registered web component that can receive the specified props.
          */
         name: string;
         /**
-         * Properties to initialize the component with
+         * Initial properties to pass to the configuration component.
+         *
+         * These props configure the initial state of the configuration UI.
          */
         props?: Record<string, unknown>;
     };
 };
 /**
- * Metadata about a package using Lime Web Components
+ * Metadata describing a package or addon using Lime Web Components.
+ *
+ * This metadata is defined in the package's `package.json` file under the
+ * `lime` field. The system reads this metadata before installing
+ * a package to ensure compatibility between the package and the target
+ * Lime CRM client environment.
+ *
+ * Packages should declare which platforms they support to prevent installation
+ * in incompatible environments.
+ *
+ * @example
+ * ```json
+ * // In package.json
+ * {
+ *   "name": "my-addon",
+ *   "version": "1.0.0",
+ *   "lime": {
+ *     "platforms": ["LimeCRMWebClient", "LimeCRMDesktopClient"]
+ *   }
+ * }
+ * ```
  *
  * @group Core
  * @beta
  */
 export interface LimePackageMetadata {
     /**
-     * The platforms this package is compatible with
+     * List of platform types this package is compatible with.
+     *
+     * If specified, the package will only be loaded on the listed platforms.
+     * Omitting this field means the package is compatible with all platforms.
+     *
+     * Platform types:
+     * - `LimeCRMWebClient` - Standard web browser client
+     * - `LimeCRMDesktopClient` - Desktop application client
+     * - `LimeCRMWebAdminClient` - Administrative web interface
+     *
+     * @example
+     * ```json
+     * // Web-only package
+     * {
+     *   "lime": {
+     *     "platforms": ["LimeCRMWebClient", "LimeCRMWebAdminClient"]
+     *   }
+     * }
+     * ```
      */
     platforms?: Array<LimeWebComponentPlatform['type']>;
 }

package/dist/core/metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/core/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAK9B,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,GAAG;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;OAEG;IACH,eAAe,CAAC,EAAE;QACd;;WAEG;QACH,IAAI,EAAE,MAAM,CAAC;QAEb;;WAEG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC,CAAC;CACL,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAChC;;OAEG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,CAAC;CACvD"}
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/core/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAK9B,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,MAAM,cAAc,GAAG;IACzB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE;QACd;;;;WAIG;QACH,IAAI,EAAE,MAAM,CAAC;QAEb;;;;WAIG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC,CAAC;CACL,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,CAAC;CACvD"}

package/dist/core/platform.d.ts

@@ -1,53 +1,214 @@
 /**
- * Service container for the Lime CRM platform
+ * Service container for the Lime CRM platform that provides access to all platform services.
+ *
+ * The platform acts as a service locator for accessing repositories, the command bus,
+ * HTTP client, and other services throughout the application. It is used by web components
+ * (injected via Stencil's `@Prop` decorator), command handlers, and other parts of the system.
+ *
+ * The platform type indicates which Lime CRM client is hosting the component:
+ * - `LimeCRMWebClient`: Standard web client
+ * - `LimeCRMDesktopClient`: Desktop application client
+ * - `LimeCRMWebAdminClient`: Administrative web interface
+ *
+ * @example
+ * ```typescript
+ * // Get core services
+ * const http = platform.get(PlatformServiceName.Http);
+ * const commandBus = platform.get(PlatformServiceName.CommandBus);
+ * const limetypes = platform.get(PlatformServiceName.LimeTypeRepository);
+ *
+ * // Check platform type for conditional logic
+ * if (platform.type === 'LimeCRMDesktopClient') {
+ *     // Desktop-specific functionality
+ * }
+ *
+ * // Check feature switches
+ * if (platform.isFeatureEnabled('newFeature')) {
+ *     // Use new feature
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Register a custom service (third-party plugins)
+ * platform.register('myPlugin.analytics', new AnalyticsService());
+ *
+ * // Later retrieve it
+ * const analytics = platform.get('myPlugin.analytics');
+ * ```
+ *
  * @public
  * @group Core
  */
 export interface LimeWebComponentPlatform {
+    /**
+     * The type of Lime CRM client currently running.
+     * Use this to conditionally enable features based on the client environment.
+     */
     type: 'LimeCRMWebClient' | 'LimeCRMDesktopClient' | 'LimeCRMWebAdminClient';
     /**
-     * Get a service
+     * Get a service from the platform container.
+     *
+     * Services are accessed through the `PlatformServiceName` enum, which can be extended
+     * by third-party modules using module augmentation.
+     *
+     * @param name - The name of the service to retrieve
+     * @returns The requested service instance
      *
-     * @param name - the name of the service
+     * @example
+     * ```typescript
+     * const http = platform.get(PlatformServiceName.Http);
+     * const repository = platform.get(PlatformServiceName.LimeObjectRepository);
+     * ```
      */
     get(name: string): any;
     /**
-     * Check if a service is currently registered on the platform
+     * Check if a service is currently registered on the platform.
      *
-     * @param name - the name of the service
+     * Useful for optional dependencies or checking service availability.
+     *
+     * @param name - The name of the service to check
+     * @returns `true` if the service is registered, `false` otherwise
+     *
+     * @example
+     * ```typescript
+     * if (platform.has(PlatformServiceName.Analytics)) {
+     *     const tracker = platform.get(PlatformServiceName.Analytics);
+     *     tracker.track('event');
+     * }
+     * ```
      */
     has(name: string): boolean;
     /**
-     * Register a service on the platform
+     * Register a service on the platform for use throughout the application.
+     *
+     * Service names are typically defined in the `PlatformServiceName` enum through module
+     * augmentation. This ensures type safety and prevents naming conflicts.
+     *
+     * @param name - The name to register the service under
+     * @param service - The service instance to register
      *
-     * Core platform service names are defined by the enum `PlatformServiceName`. Third parties that wants to register
-     * a service should add a prefix to the service name, e.g. the plugin name.
+     * @example
+     * ```typescript
+     * const SERVICE_NAME = 'myPlugin.cache';
+     * PlatformServiceName.MyCache = SERVICE_NAME;
      *
-     * @param name - the name of the service
-     * @param service - the service
+     * declare module '@limetech/lime-web-components' {
+     *     interface PlatformServiceNameType {
+     *         MyCache: typeof SERVICE_NAME;
+     *     }
+     *
+     *     interface LimeWebComponentPlatform {
+     *         get(name: PlatformServiceNameType['MyCache']): CacheService;
+     *     }
+     * }
+     *
+     * // Register the service
+     * platform.register(PlatformServiceName.MyCache, new CacheService());
+     * ```
      */
     register(name: string, service: any): void;
     /**
-     * Check if a feature is enabled
+     * Check if a feature is enabled in the current environment.
+     *
+     * Feature switches allow gradual rollout of new functionality and
+     * environment-specific behavior. Features can be enabled/disabled
+     * at the application, user, or system level.
+     *
+     * @param name - Name of the feature switch to check
+     * @returns `true` if the feature is enabled, `false` otherwise
      *
-     * @param name - name of the feature switch
+     * @example
+     * ```typescript
+     * // Use feature switches for gradual rollout
+     * if (platform.isFeatureEnabled('advancedSearch')) {
+     *     return new AdvancedSearchComponent();
+     * } else {
+     *     return new BasicSearchComponent();
+     * }
+     * ```
      */
     isFeatureEnabled(name: keyof FeatureSwitches): boolean;
 }
 /**
- * Core platform service names
+ * Core platform service names for accessing built-in services via the platform.
+ *
+ * Use these strongly-typed keys to retrieve platform services.
+ *
+ * @example
+ * ```typescript
+ * const http = platform.get(PlatformServiceName.Http);
+ * const commandBus = platform.get(PlatformServiceName.CommandBus);
+ * const limeObjects = platform.get(PlatformServiceName.LimeObjectRepository);
+ * const limeTypes = platform.get(PlatformServiceName.LimeTypeRepository);
+ * const navigator = platform.get(PlatformServiceName.Navigator);
+ * ```
+ *
+ * @remarks
+ * Available services include:
+ * - `Http` - HTTP client for API requests
+ * - `CommandBus` - Command pattern implementation for actions
+ * - `LimeObjectRepository` - CRUD operations for business objects
+ * - `LimeTypeRepository` - Schema and metadata access
+ * - `Navigator` - Client-side routing
+ * - `EventDispatcher` - Event pub/sub system
+ * - `Translator` - Localization service
+ * - And many more...
+ *
  * @public
  * @group Core
  */
 export declare const PlatformServiceName: PlatformServiceNameType;
 /**
+ * Interface for platform service names that gets augmented by each service module.
+ *
+ * Each platform service extends this interface through module augmentation to add
+ * its service name. This pattern provides compile-time type safety for service names.
+ *
+ * @example
+ * ```typescript
+ * // How services augment this interface (done internally by each service):
+ * const SERVICE_NAME = 'http';
+ * PlatformServiceName.Http = SERVICE_NAME;
+ *
+ * declare module '@limetech/lime-web-components' {
+ *     interface PlatformServiceNameType {
+ *         Http: typeof SERVICE_NAME;
+ *     }
+ *
+ *     interface LimeWebComponentPlatform {
+ *         get(name: PlatformServiceNameType['Http']): HttpService;
+ *     }
+ * }
+ * ```
+ *
  * @public
  * @group Core
  */
 export interface PlatformServiceNameType {
 }
 /**
- * Available feature switches
+ * Available feature switches for conditional functionality.
+ *
+ * Feature switches enable gradual rollout and A/B testing of new features.
+ * This interface is augmented by feature modules to register their switches.
+ *
+ * @example
+ * ```typescript
+ * // How features augment this interface:
+ * declare module '@limetech/lime-web-components' {
+ *     interface FeatureSwitches {
+ *         advancedSearch: boolean;
+ *         newUIDesign: boolean;
+ *         betaFeatures: boolean;
+ *     }
+ * }
+ *
+ * // Usage in components:
+ * if (platform.isFeatureEnabled('advancedSearch')) {
+ *     // Enable advanced search functionality
+ * }
+ * ```
  *
  * @public
  * @group Core

package/dist/core/platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/core/platform.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACrC,IAAI,EAAE,kBAAkB,GAAG,sBAAsB,GAAG,uBAAuB,CAAC;IAE5E;;;;OAIG;IAEH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC;IAEvB;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAE3B;;;;;;;;OAQG;IAEH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAE3C;;;;OAIG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,eAAe,GAAG,OAAO,CAAC;CAC1D;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,uBAEK,CAAC;AAExC;;;GAGG;AACH,MAAM,WAAW,uBAAuB;CAAG;AAE3C;;;;;GAKG;AACH,MAAM,WAAW,eAAe;CAAG"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/core/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,WAAW,wBAAwB;IACrC;;;OAGG;IACH,IAAI,EAAE,kBAAkB,GAAG,sBAAsB,GAAG,uBAAuB,CAAC;IAE5E;;;;;;;;;;;;;;OAcG;IAEH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC;IAEvB;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IAEH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,eAAe,GAAG,OAAO,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,mBAAmB,EAAE,uBAEK,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,uBAAuB;CAAG;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,eAAe;CAAG"}