@limetech/lime-web-components 6.6.0 → 6.8.0

package/dist/problem/query.d.ts

@@ -0,0 +1,312 @@
+import { Icon } from '../core';
+import { ProblemSeverity } from './problem';
+/**
+ * Filter for querying problems related to {@link LimeObject}s.
+ *
+ * Used with {@link ProblemQueryOptions.context} to find problems linked to
+ * specific limeobjects. The limetype is always required, while id is optional:
+ * - With only `limetype`: Returns all problems related to that object type
+ * - With both `limetype` and `id`: Returns problems for that specific object
+ *
+ * @example
+ * Find all problems related to contacts
+ * ```typescript
+ * const contactProblems = await provider.getProblems({
+ *     context: { limetype: 'contact' }
+ * });
+ * ```
+ *
+ * @example
+ * Find problems for a specific deal
+ * ```typescript
+ * const dealProblems = await provider.getProblems({
+ *     context: {
+ *         limetype: 'deal',
+ *         id: 12345
+ *     }
+ * });
+ * ```
+ *
+ * @see {@link ProblemQueryOptions.context}
+ * @see {@link ProblemContext} for the context stored on problems
+ *
+ * @alpha
+ * @group Problem
+ */
+export type ProblemContextFilter = {
+    /**
+     * The limetype to filter by (e.g., 'contact', 'deal', 'company').
+     *
+     * This is required because object ids are only unique within a limetype.
+     */
+    limetype: string;
+    /**
+     * The specific object id to filter by.
+     *
+     * When omitted, matches all problems related to the specified limetype.
+     */
+    id?: number;
+};
+/**
+ * Options for querying problems from a {@link ProblemProvider}.
+ *
+ * All filter properties are optional. Providers handle what they support and
+ * silently ignore unsupported filters. This allows the platform to pass a
+ * consistent set of filters without needing to know each provider's capabilities.
+ *
+ * Multiple values can be provided for most filters (severity, status, type, tags)
+ * to match problems that have any of the specified values (OR logic).
+ *
+ * @example
+ * Get all open problems
+ * ```typescript
+ * const openProblems = await provider.getProblems({
+ *     status: 'open'
+ * });
+ * ```
+ *
+ * @example
+ * Get high-priority unresolved problems with pagination
+ * ```typescript
+ * const urgentProblems = await provider.getProblems({
+ *     severity: [ProblemSeverity.High, ProblemSeverity.Critical],
+ *     status: ['open', 'acknowledged'],
+ *     limit: 20,
+ *     offset: 0
+ * });
+ * ```
+ *
+ * @example
+ * Get problems for a specific type and user
+ * ```typescript
+ * const userEmailProblems = await provider.getProblems({
+ *     type: 'email.delivery-failed',
+ *     userId: 'user-123'
+ * });
+ * ```
+ *
+ * @example
+ * Get problems related to a specific limeobject
+ * ```typescript
+ * const dealProblems = await provider.getProblems({
+ *     context: {
+ *         limetype: 'deal',
+ *         id: 98765
+ *     }
+ * });
+ * ```
+ *
+ * @see {@link ProblemProvider.getProblems}
+ * @see {@link ProblemProvider.getCount}
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemQueryOptions {
+    /**
+     * Filter by severity level(s).
+     *
+     * When a single value is provided, returns problems with that severity.
+     * When an array is provided, returns problems matching any of the severities.
+     *
+     * @see {@link ProblemSeverity}
+     */
+    severity?: ProblemSeverity | ProblemSeverity[];
+    /**
+     * Filter by status(es).
+     *
+     * Status values are provider-defined strings. When a single value is provided,
+     * returns problems with that status. When an array is provided, returns
+     * problems matching any of the statuses.
+     *
+     * @see {@link Problem.status}
+     */
+    status?: string | string[];
+    /**
+     * Filter by problem type(s).
+     *
+     * Types are provider-specific strings like 'email.delivery-failed' or
+     * 'sync.connection-error'. When an array is provided, returns problems
+     * matching any of the types.
+     *
+     * @see {@link Problem."type"}
+     */
+    type?: string | string[];
+    /**
+     * Filter by tag(s).
+     *
+     * Returns problems that have any of the specified tags (OR logic).
+     *
+     * @see {@link Problem.tags}
+     */
+    tags?: string[];
+    /**
+     * Filter by user identifier.
+     *
+     * Returns problems associated with the specified user.
+     *
+     * @see {@link Problem.userId}
+     */
+    userId?: string;
+    /**
+     * Filter by related {@link LimeObject}.
+     *
+     * Use this to find problems linked to a specific limetype or object instance.
+     *
+     * @see {@link ProblemContextFilter}
+     * @see {@link Problem.context}
+     */
+    context?: ProblemContextFilter;
+    /**
+     * Maximum number of problems to return.
+     *
+     * Used for pagination. When omitted, the provider decides the default limit.
+     */
+    limit?: number;
+    /**
+     * Number of problems to skip before returning results.
+     *
+     * Used for pagination in combination with `limit`. For example, to get
+     * the second page of 20 items, use `{ limit: 20, offset: 20 }`.
+     */
+    offset?: number;
+}
+/**
+ * Display information for a problem type.
+ *
+ * Providers define multiple problem types (e.g., an Email Integration provider
+ * might have 'delivery-failed', 'validation-error', 'attachment-too-large').
+ * ProblemType provides the human-readable display information for each type.
+ *
+ * The platform retrieves this information via {@link ProblemProvider.getType}
+ * and {@link ProblemProvider.getTypes} to display problems with appropriate
+ * titles and icons.
+ *
+ * @example
+ * Implementing type methods in a provider
+ * ```typescript
+ * class EmailProblemProvider implements ProblemProvider {
+ *     private types: ProblemType[] = [
+ *         {
+ *             id: 'delivery-failed',
+ *             title: 'Delivery Failed',
+ *             description: 'Email could not be delivered to the recipient',
+ *             icon: 'envelope-exclamation'
+ *         },
+ *         {
+ *             id: 'validation-error',
+ *             title: 'Validation Error'
+ *         }
+ *     ];
+ *
+ *     getTypes(): ProblemType[] {
+ *         return this.types;
+ *     }
+ *
+ *     getType(type: string): ProblemType | undefined {
+ *         return this.types.find(t => t.id === type);
+ *     }
+ * }
+ * ```
+ *
+ * @see {@link ProblemProvider.getType}
+ * @see {@link ProblemProvider.getTypes}
+ * @see {@link Problem."type"}
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemType {
+    /**
+     * The type identifier as used in {@link Problem."type"}.
+     */
+    id: string;
+    /**
+     * Human-readable title for the problem type.
+     *
+     * Displayed as the primary label for problems of this type. Should be
+     * concise but descriptive (e.g., 'Delivery Failed', 'Connection Error').
+     */
+    title: string;
+    /**
+     * Detailed description of what this type of problem means.
+     *
+     * Provides context to help users understand the nature of the problem.
+     * May be displayed in tooltips or detail views.
+     */
+    description?: string;
+    /**
+     * Icon to display for problems of this type.
+     *
+     * Can be either a string referencing an icon name from the platform's icon
+     * library, or an {@link Icon} object with additional properties like color.
+     *
+     * @see {@link Icon}
+     */
+    icon?: string | Icon;
+}
+/**
+ * Display information for a problem status.
+ *
+ * Since status values are provider-defined, providers must supply display
+ * information for their statuses so the platform can render them appropriately.
+ *
+ * @example
+ * Implementing getStatus in a provider
+ * ```typescript
+ * class EmailProblemProvider implements ProblemProvider {
+ *     private statusInfoMap: Record<string, ProblemStatus> = {
+ *         'open': {
+ *             id: 'open',
+ *             title: 'Open',
+ *             icon: 'circle'
+ *         },
+ *         'pending-retry': {
+ *             id: 'pending-retry',
+ *             title: 'Pending Retry',
+ *             icon: 'clock'
+ *         },
+ *         'resolved': {
+ *             id: 'resolved',
+ *             title: 'Resolved',
+ *             icon: 'check-circle'
+ *         }
+ *     };
+ *
+ *     getStatus(status: string): ProblemStatus | undefined {
+ *         return this.statusInfoMap[status];
+ *     }
+ *
+ *     getStatuses(): ProblemStatus[] {
+ *         return Object.values(this.statusInfoMap);
+ *     }
+ * }
+ * ```
+ *
+ * @see {@link ProblemProvider.getStatus}
+ * @see {@link ProblemProvider.getStatuses}
+ * @see {@link Problem.status}
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemStatus {
+    /**
+     * The status identifier as used in {@link Problem.status}.
+     */
+    id: string;
+    /**
+     * Human-readable title for the status.
+     */
+    title: string;
+    /**
+     * Icon to display for this status.
+     *
+     * Can be either a string referencing an icon name from the platform's icon
+     * library, or an {@link Icon} object with additional properties like color.
+     *
+     * @see {@link Icon}
+     */
+    icon?: string | Icon;
+}
+//# sourceMappingURL=query.d.ts.map

package/dist/problem/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/problem/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAC/B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,eAAe,GAAG,eAAe,EAAE,CAAC;IAE/C;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE3B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEzB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAE/B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,WAAW,WAAW;IACxB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB"}

package/dist/problem/repository.d.ts

@@ -0,0 +1,111 @@
+import { Problem } from './problem';
+import { ProblemProvider } from './provider';
+import { ProblemQueryOptions } from './query';
+/**
+ * Repository for accessing problems from registered providers.
+ *
+ * The repository is the primary interface for consumers to interact with
+ * problems. It provides a unified API for querying, counting, and retrieving
+ * problems from registered {@link ProblemProvider}s.
+ *
+ * Packages register their providers with the repository during initialization.
+ * Consumers then use the repository's query methods rather than interacting
+ * with providers directly.
+ *
+ * @example
+ * Registering a provider
+ * ```typescript
+ * const repository = platform.get(PlatformServiceName.ProblemRepository);
+ * repository.registerProvider(new EmailProblemProvider());
+ * ```
+ *
+ * @example
+ * Fetching problems from a provider
+ * ```typescript
+ * const repository = platform.get(PlatformServiceName.ProblemRepository);
+ * const problems = await repository.getProblems('email-integration', {
+ *     severity: ProblemSeverity.Critical
+ * });
+ * ```
+ *
+ * @example
+ * Getting actions for a problem
+ * ```typescript
+ * const problem = await repository.get('email-integration', 'prob-123');
+ * const provider = repository.getProvider(problem.providerId);
+ * const actions = provider.getActions(problem);
+ * ```
+ *
+ * @see {@link ProblemProvider} for the provider interface
+ *
+ * @alpha
+ * @group Problem
+ */
+export interface ProblemRepository {
+    /**
+     * Registers a problem provider with the repository.
+     *
+     * The provider's {@link ProblemProvider.id} must be unique. Registering
+     * a provider with an id that already exists will throw an error.
+     *
+     * @param provider - The provider to register. Must have a unique id.
+     * @throws Error if a provider with the same id is already registered.
+     */
+    registerProvider(provider: ProblemProvider): void;
+    /**
+     * Returns all registered providers.
+     *
+     * Useful for displaying provider information in the UI, such as
+     * provider titles and icons for filtering.
+     *
+     * @returns An array of all registered providers.
+     */
+    getProviders(): ProblemProvider[];
+    /**
+     * Returns a specific provider by its id.
+     *
+     * @param id - The unique identifier of the provider.
+     * @returns The provider if found, undefined otherwise.
+     */
+    getProvider(id: string): ProblemProvider | undefined;
+    /**
+     * Fetches problems from a provider matching the query options.
+     *
+     * @param providerId - The provider id to query.
+     * @param options - Optional filtering and pagination options.
+     * @returns A promise resolving to an array of problems.
+     * @throws Error if no provider with the given id is registered.
+     *
+     * @example
+     * ```typescript
+     * const emailProblems = await repository.getProblems('email-integration');
+     *
+     * const criticalProblems = await repository.getProblems(
+     *     'email-integration',
+     *     { severity: ProblemSeverity.Critical }
+     * );
+     * ```
+     */
+    getProblems(providerId: string, options?: ProblemQueryOptions): Promise<Problem[]>;
+    /**
+     * Returns the count of problems from a provider.
+     *
+     * More efficient than fetching all problems when only the count is needed.
+     *
+     * @param providerId - The provider id to query.
+     * @param options - Optional filtering options.
+     * @returns A promise resolving to the count.
+     * @throws Error if no provider with the given id is registered.
+     */
+    getCount(providerId: string, options?: ProblemQueryOptions): Promise<number>;
+    /**
+     * Retrieves a specific problem by provider and problem id.
+     *
+     * @param providerId - The id of the provider that owns the problem.
+     * @param problemId - The id of the problem within that provider.
+     * @returns A promise resolving to the problem if found, undefined otherwise.
+     * @throws Error if no provider with the given id is registered.
+     */
+    get(providerId: string, problemId: string): Promise<Problem | undefined>;
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/problem/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/problem/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;;;;;OAQG;IACH,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IAElD;;;;;;;OAOG;IACH,YAAY,IAAI,eAAe,EAAE,CAAC;IAElC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAC;IAErD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CACP,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAEtB;;;;;;;;;OASG;IACH,QAAQ,CACJ,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB;;;;;;;OAOG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;CAC5E"}

package/dist/problem/types.d.ts

@@ -0,0 +1,15 @@
+import { ProblemRepository as Service } from './repository';
+declare const SERVICE_NAME = "problemRepository";
+declare module '../core/platform' {
+    interface PlatformServiceNameType {
+        /**
+         * @see {@link Service | ProblemRepository}
+         */
+        ProblemRepository: typeof SERVICE_NAME;
+    }
+    interface LimeWebComponentPlatform {
+        get(name: PlatformServiceNameType['ProblemRepository']): Service;
+    }
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/problem/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/problem/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5D,QAAA,MAAM,YAAY,sBAAsB,CAAC;AAIzC,OAAO,QAAQ,kBAAkB,CAAC;IAC9B,UAAU,uBAAuB;QAC7B;;WAEG;QACH,iBAAiB,EAAE,OAAO,YAAY,CAAC;KAC1C;IACD,UAAU,wBAAwB;QAC9B,GAAG,CAAC,IAAI,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,GAAG,OAAO,CAAC;KACpE;CACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/lime-web-components",
-  "version": "6.6.0",
+  "version": "6.8.0",
   "description": "Lime Web Components",
   "author": "Lime Technologies",
   "license": "Apache-2.0",
@@ -35,21 +35,21 @@
     "tslib": "^2.8.1"
   },
   "devDependencies": {
-    "@commitlint/config-conventional": "^20.2.0",
+    "@commitlint/config-conventional": "^20.3.1",
     "@limetech/eslint-config": "^4.0.0",
     "@microsoft/api-extractor": "^7.55.2",
     "eslint": "^9.39.2",
     "expect-type": "^1.3.0",
-    "globals": "^16.5.0",
-    "jsdom": "^27.3.0",
+    "globals": "^17.2.0",
+    "jsdom": "^27.4.0",
     "replace-in-file": "^8.4.0",
     "shelljs": "0.10.0",
     "typedoc": "^0.23.24",
     "typedoc-plugin-markdown": "~3.15.0",
     "typescript": "^4.9.5",
-    "vite": "^7.3.0",
+    "vite": "^7.3.1",
     "vite-plugin-dts": "^4.5.0",
-    "vitest": "^4.0.15",
+    "vitest": "^4.0.18",
     "yargs": "^18.0.0"
   },
   "keywords": [