@doctorus/common 0.0.17 → 0.0.18

package/lib/status/index.d.ts

@@ -5,3 +5,4 @@ export * from './types';
 export * from './medical-service-status';
 export * as AccountLocationStatus from './account-location-status';
 export * as MedicalHistoryStatus from './medical-history-status';
+export * from './utils';

package/lib/status/index.js

@@ -44,4 +44,5 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./medical-service-status"), exports);
 exports.AccountLocationStatus = __importStar(require("./account-location-status"));
 exports.MedicalHistoryStatus = __importStar(require("./medical-history-status"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RhdHVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOztHQUVHO0FBQ0gsMENBQXdCO0FBQ3hCLDJEQUF5QztBQUN6QyxtRkFBbUU7QUFDbkUsaUZBQWlFIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTdGF0dXMgbW9kdWxlIGV4cG9ydHNcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL21lZGljYWwtc2VydmljZS1zdGF0dXMnO1xuZXhwb3J0ICogYXMgQWNjb3VudExvY2F0aW9uU3RhdHVzIGZyb20gJy4vYWNjb3VudC1sb2NhdGlvbi1zdGF0dXMnO1xuZXhwb3J0ICogYXMgTWVkaWNhbEhpc3RvcnlTdGF0dXMgZnJvbSAnLi9tZWRpY2FsLWhpc3Rvcnktc3RhdHVzJztcbiJdfQ==
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RhdHVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOztHQUVHO0FBQ0gsMENBQXdCO0FBQ3hCLDJEQUF5QztBQUN6QyxtRkFBbUU7QUFDbkUsaUZBQWlFO0FBQ2pFLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogU3RhdHVzIG1vZHVsZSBleHBvcnRzXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZWRpY2FsLXNlcnZpY2Utc3RhdHVzJztcbmV4cG9ydCAqIGFzIEFjY291bnRMb2NhdGlvblN0YXR1cyBmcm9tICcuL2FjY291bnQtbG9jYXRpb24tc3RhdHVzJztcbmV4cG9ydCAqIGFzIE1lZGljYWxIaXN0b3J5U3RhdHVzIGZyb20gJy4vbWVkaWNhbC1oaXN0b3J5LXN0YXR1cyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbiJdfQ==

package/lib/status/utils.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Status utilities for extracting and querying status metadata
+ * Provides common functions to work with status configurations
+ */
+import type { AccountLocationStatus } from './account-location-status';
+import type { MedicalHistoryStatus } from './medical-history-status';
+import type { MedicalServiceStatus } from './medical-service-status';
+import type { StatusMetadata, Locale } from './types';
+/**
+ * Feature type for status selection
+ */
+export type StatusFeature = 'medicalService' | 'accountLocation' | 'medicalHistory';
+/**
+ * Status type mapping for each feature
+ */
+export type StatusTypeMap = {
+    medicalService: MedicalServiceStatus;
+    accountLocation: AccountLocationStatus;
+    medicalHistory: MedicalHistoryStatus;
+};
+/**
+ * Get status metadata for a specific feature and status
+ * @param feature - The feature name (e.g., 'medicalService', 'accountLocation')
+ * @param status - The status value
+ * @returns The complete StatusMetadata for the given feature and status
+ * @throws Error if feature or status is not found
+ */
+export declare function getStatusMetadataForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T]): StatusMetadata;
+/**
+ * Get status icon for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @returns The Material icon name
+ */
+export declare function getStatusIconForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T]): string;
+/**
+ * Get status color for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @returns The hex color code
+ */
+export declare function getStatusColorForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T]): string;
+/**
+ * Get status label for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @param locale - The language locale (default: 'us-EN')
+ * @param format - Label format: 'short' or 'long' (default: 'short')
+ * @returns The translated label
+ */
+export declare function getStatusLabelForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T], locale?: Locale, format?: 'short' | 'long'): string;
+/**
+ * Get status description for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @param locale - The language locale (default: 'us-EN')
+ * @returns The translated description
+ */
+export declare function getStatusDescriptionForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T], locale?: Locale): string;
+/**
+ * Get all metadata for a specific feature
+ * @param feature - The feature name
+ * @returns Record of all statuses and their metadata for the feature
+ */
+export declare function getAllStatusMetadataForFeature<T extends StatusFeature>(feature: T): Record<StatusTypeMap[T], StatusMetadata>;
+/**
+ * Get all statuses for a specific feature
+ * @param feature - The feature name
+ * @returns Array of all status values for the feature
+ */
+export declare function getAllStatusesForFeature<T extends StatusFeature>(feature: T): StatusTypeMap[T][];
+/**
+ * Filter statuses by criteria
+ * @param feature - The feature name
+ * @param predicate - Function to test each status metadata
+ * @returns Array of statuses that match the predicate
+ */
+export declare function filterStatusesByFeature<T extends StatusFeature>(feature: T, predicate: (metadata: StatusMetadata, status: StatusTypeMap[T]) => boolean): StatusTypeMap[T][];
+/**
+ * Map statuses to a specific value using a transform function
+ * @param feature - The feature name
+ * @param transform - Function to transform each status metadata
+ * @returns Record of statuses mapped to the transformed values
+ */
+export declare function mapStatusesByFeature<T extends StatusFeature, U>(feature: T, transform: (metadata: StatusMetadata, status: StatusTypeMap[T]) => U): Record<StatusTypeMap[T], U>;
+/**
+ * Get status metadata with computed properties
+ * @param feature - The feature name
+ * @param status - The status value
+ * @param locale - The language locale
+ * @returns Extended metadata with computed labels and description
+ */
+export interface ExtendedStatusMetadata extends Omit<StatusMetadata, 'description'> {
+    shortLabel: string;
+    longLabel: string;
+    description: string;
+}
+export declare function getExtendedStatusMetadataForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T], locale?: Locale): ExtendedStatusMetadata;
+/**
+ * Search statuses by label
+ * @param feature - The feature name
+ * @param searchTerm - The search term (case-insensitive)
+ * @param locale - The language locale
+ * @returns Array of statuses matching the search term
+ */
+export declare function searchStatusesByFeature<T extends StatusFeature>(feature: T, searchTerm: string, locale?: Locale): StatusTypeMap[T][];
+/**
+ * Get status metadata grouped by color
+ * @param feature - The feature name
+ * @returns Record of colors mapped to arrays of statuses
+ */
+export declare function groupStatusesByColorForFeature<T extends StatusFeature>(feature: T): Record<string, StatusTypeMap[T][]>;
+/**
+ * Get status metadata grouped by icon
+ * @param feature - The feature name
+ * @returns Record of icons mapped to arrays of statuses
+ */
+export declare function groupStatusesByIconForFeature<T extends StatusFeature>(feature: T): Record<string, StatusTypeMap[T][]>;

package/lib/status/utils.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Status utilities for extracting and querying status metadata
+ * Provides common functions to work with status configurations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatusMetadataForFeature = getStatusMetadataForFeature;
+exports.getStatusIconForFeature = getStatusIconForFeature;
+exports.getStatusColorForFeature = getStatusColorForFeature;
+exports.getStatusLabelForFeature = getStatusLabelForFeature;
+exports.getStatusDescriptionForFeature = getStatusDescriptionForFeature;
+exports.getAllStatusMetadataForFeature = getAllStatusMetadataForFeature;
+exports.getAllStatusesForFeature = getAllStatusesForFeature;
+exports.filterStatusesByFeature = filterStatusesByFeature;
+exports.mapStatusesByFeature = mapStatusesByFeature;
+exports.getExtendedStatusMetadataForFeature = getExtendedStatusMetadataForFeature;
+exports.searchStatusesByFeature = searchStatusesByFeature;
+exports.groupStatusesByColorForFeature = groupStatusesByColorForFeature;
+exports.groupStatusesByIconForFeature = groupStatusesByIconForFeature;
+const account_location_status_1 = require("./account-location-status");
+const medical_history_status_1 = require("./medical-history-status");
+const medical_service_status_1 = require("./medical-service-status");
+/**
+ * Metadata registry mapping features to their status configurations
+ */
+const METADATA_REGISTRY = {
+    medicalService: medical_service_status_1.MEDICAL_SERVICE_STATUS_METADATA,
+    accountLocation: account_location_status_1.ACCOUNT_LOCATION_STATUS_METADATA,
+    medicalHistory: medical_history_status_1.MEDICAL_HISTORY_STATUS_METADATA,
+};
+/**
+ * Get status metadata for a specific feature and status
+ * @param feature - The feature name (e.g., 'medicalService', 'accountLocation')
+ * @param status - The status value
+ * @returns The complete StatusMetadata for the given feature and status
+ * @throws Error if feature or status is not found
+ */
+function getStatusMetadataForFeature(feature, status) {
+    const registry = METADATA_REGISTRY[feature];
+    if (!registry) {
+        throw new Error(`Unknown status feature: ${feature}`);
+    }
+    const metadata = registry[status];
+    if (!metadata) {
+        throw new Error(`Unknown status for feature ${feature}: ${status}`);
+    }
+    return metadata;
+}
+/**
+ * Get status icon for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @returns The Material icon name
+ */
+function getStatusIconForFeature(feature, status) {
+    return getStatusMetadataForFeature(feature, status).icon;
+}
+/**
+ * Get status color for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @returns The hex color code
+ */
+function getStatusColorForFeature(feature, status) {
+    return getStatusMetadataForFeature(feature, status).color;
+}
+/**
+ * Get status label for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @param locale - The language locale (default: 'us-EN')
+ * @param format - Label format: 'short' or 'long' (default: 'short')
+ * @returns The translated label
+ */
+function getStatusLabelForFeature(feature, status, locale = 'us-EN', format = 'short') {
+    const metadata = getStatusMetadataForFeature(feature, status);
+    return metadata.label[format][locale];
+}
+/**
+ * Get status description for a specific feature and status
+ * @param feature - The feature name
+ * @param status - The status value
+ * @param locale - The language locale (default: 'us-EN')
+ * @returns The translated description
+ */
+function getStatusDescriptionForFeature(feature, status, locale = 'us-EN') {
+    return getStatusMetadataForFeature(feature, status).description[locale];
+}
+/**
+ * Get all metadata for a specific feature
+ * @param feature - The feature name
+ * @returns Record of all statuses and their metadata for the feature
+ */
+function getAllStatusMetadataForFeature(feature) {
+    const registry = METADATA_REGISTRY[feature];
+    if (!registry) {
+        throw new Error(`Unknown status feature: ${feature}`);
+    }
+    return registry;
+}
+/**
+ * Get all statuses for a specific feature
+ * @param feature - The feature name
+ * @returns Array of all status values for the feature
+ */
+function getAllStatusesForFeature(feature) {
+    const metadata = getAllStatusMetadataForFeature(feature);
+    return Object.keys(metadata);
+}
+/**
+ * Filter statuses by criteria
+ * @param feature - The feature name
+ * @param predicate - Function to test each status metadata
+ * @returns Array of statuses that match the predicate
+ */
+function filterStatusesByFeature(feature, predicate) {
+    const metadata = getAllStatusMetadataForFeature(feature);
+    return Object.entries(metadata)
+        .filter(([status, meta]) => predicate(meta, status))
+        .map(([status]) => status);
+}
+/**
+ * Map statuses to a specific value using a transform function
+ * @param feature - The feature name
+ * @param transform - Function to transform each status metadata
+ * @returns Record of statuses mapped to the transformed values
+ */
+function mapStatusesByFeature(feature, transform) {
+    const metadata = getAllStatusMetadataForFeature(feature);
+    const result = {};
+    Object.entries(metadata).forEach(([status, meta]) => {
+        result[status] = transform(meta, status);
+    });
+    return result;
+}
+function getExtendedStatusMetadataForFeature(feature, status, locale = 'us-EN') {
+    const metadata = getStatusMetadataForFeature(feature, status);
+    return {
+        icon: metadata.icon,
+        color: metadata.color,
+        label: metadata.label,
+        shortLabel: metadata.label.short[locale],
+        longLabel: metadata.label.long[locale],
+        description: metadata.description[locale],
+    };
+}
+/**
+ * Search statuses by label
+ * @param feature - The feature name
+ * @param searchTerm - The search term (case-insensitive)
+ * @param locale - The language locale
+ * @returns Array of statuses matching the search term
+ */
+function searchStatusesByFeature(feature, searchTerm, locale = 'us-EN') {
+    const lowerSearch = searchTerm.toLowerCase();
+    return filterStatusesByFeature(feature, (metadata) => {
+        const shortLabel = metadata.label.short[locale].toLowerCase();
+        const longLabel = metadata.label.long[locale].toLowerCase();
+        const description = metadata.description[locale].toLowerCase();
+        return shortLabel.includes(lowerSearch) || longLabel.includes(lowerSearch) || description.includes(lowerSearch);
+    });
+}
+/**
+ * Get status metadata grouped by color
+ * @param feature - The feature name
+ * @returns Record of colors mapped to arrays of statuses
+ */
+function groupStatusesByColorForFeature(feature) {
+    const metadata = getAllStatusMetadataForFeature(feature);
+    const grouped = {};
+    Object.entries(metadata).forEach(([status, meta]) => {
+        const metaTyped = meta;
+        if (!grouped[metaTyped.color]) {
+            grouped[metaTyped.color] = [];
+        }
+        grouped[metaTyped.color].push(status);
+    });
+    return grouped;
+}
+/**
+ * Get status metadata grouped by icon
+ * @param feature - The feature name
+ * @returns Record of icons mapped to arrays of statuses
+ */
+function groupStatusesByIconForFeature(feature) {
+    const metadata = getAllStatusMetadataForFeature(feature);
+    const grouped = {};
+    Object.entries(metadata).forEach(([status, meta]) => {
+        const metaTyped = meta;
+        if (!grouped[metaTyped.icon]) {
+            grouped[metaTyped.icon] = [];
+        }
+        grouped[metaTyped.icon].push(status);
+    });
+    return grouped;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/status/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Status utilities for extracting and querying status metadata\n * Provides common functions to work with status configurations\n */\n\nimport type { AccountLocationStatus } from './account-location-status';\nimport type { MedicalHistoryStatus } from './medical-history-status';\nimport type { MedicalServiceStatus } from './medical-service-status';\nimport type { StatusMetadata, Locale } from './types';\nimport { ACCOUNT_LOCATION_STATUS_METADATA } from './account-location-status';\nimport { MEDICAL_HISTORY_STATUS_METADATA } from './medical-history-status';\nimport { MEDICAL_SERVICE_STATUS_METADATA } from './medical-service-status';\n\n/**\n * Feature type for status selection\n */\nexport type StatusFeature = 'medicalService' | 'accountLocation' | 'medicalHistory';\n\n/**\n * Status type mapping for each feature\n */\nexport type StatusTypeMap = {\n  medicalService: MedicalServiceStatus;\n  accountLocation: AccountLocationStatus;\n  medicalHistory: MedicalHistoryStatus;\n};\n\n/**\n * Metadata registry mapping features to their status configurations\n */\nconst METADATA_REGISTRY: Record<StatusFeature, Record<string | number, StatusMetadata>> = {\n  medicalService: MEDICAL_SERVICE_STATUS_METADATA,\n  accountLocation: ACCOUNT_LOCATION_STATUS_METADATA,\n  medicalHistory: MEDICAL_HISTORY_STATUS_METADATA,\n};\n\n/**\n * Get status metadata for a specific feature and status\n * @param feature - The feature name (e.g., 'medicalService', 'accountLocation')\n * @param status - The status value\n * @returns The complete StatusMetadata for the given feature and status\n * @throws Error if feature or status is not found\n */\nexport function getStatusMetadataForFeature<T extends StatusFeature>(\n  feature: T,\n  status: StatusTypeMap[T],\n): StatusMetadata {\n  const registry = METADATA_REGISTRY[feature];\n  if (!registry) {\n    throw new Error(`Unknown status feature: ${feature}`);\n  }\n\n  const metadata = registry[status];\n  if (!metadata) {\n    throw new Error(`Unknown status for feature ${feature}: ${status}`);\n  }\n\n  return metadata;\n}\n\n/**\n * Get status icon for a specific feature and status\n * @param feature - The feature name\n * @param status - The status value\n * @returns The Material icon name\n */\nexport function getStatusIconForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T]): string {\n  return getStatusMetadataForFeature(feature, status).icon;\n}\n\n/**\n * Get status color for a specific feature and status\n * @param feature - The feature name\n * @param status - The status value\n * @returns The hex color code\n */\nexport function getStatusColorForFeature<T extends StatusFeature>(feature: T, status: StatusTypeMap[T]): string {\n  return getStatusMetadataForFeature(feature, status).color;\n}\n\n/**\n * Get status label for a specific feature and status\n * @param feature - The feature name\n * @param status - The status value\n * @param locale - The language locale (default: 'us-EN')\n * @param format - Label format: 'short' or 'long' (default: 'short')\n * @returns The translated label\n */\nexport function getStatusLabelForFeature<T extends StatusFeature>(\n  feature: T,\n  status: StatusTypeMap[T],\n  locale: Locale = 'us-EN',\n  format: 'short' | 'long' = 'short',\n): string {\n  const metadata = getStatusMetadataForFeature(feature, status);\n  return metadata.label[format][locale];\n}\n\n/**\n * Get status description for a specific feature and status\n * @param feature - The feature name\n * @param status - The status value\n * @param locale - The language locale (default: 'us-EN')\n * @returns The translated description\n */\nexport function getStatusDescriptionForFeature<T extends StatusFeature>(\n  feature: T,\n  status: StatusTypeMap[T],\n  locale: Locale = 'us-EN',\n): string {\n  return getStatusMetadataForFeature(feature, status).description[locale];\n}\n\n/**\n * Get all metadata for a specific feature\n * @param feature - The feature name\n * @returns Record of all statuses and their metadata for the feature\n */\nexport function getAllStatusMetadataForFeature<T extends StatusFeature>(\n  feature: T,\n): Record<StatusTypeMap[T], StatusMetadata> {\n  const registry = METADATA_REGISTRY[feature];\n  if (!registry) {\n    throw new Error(`Unknown status feature: ${feature}`);\n  }\n  return registry as Record<StatusTypeMap[T], StatusMetadata>;\n}\n\n/**\n * Get all statuses for a specific feature\n * @param feature - The feature name\n * @returns Array of all status values for the feature\n */\nexport function getAllStatusesForFeature<T extends StatusFeature>(feature: T): StatusTypeMap[T][] {\n  const metadata = getAllStatusMetadataForFeature(feature);\n  return Object.keys(metadata) as StatusTypeMap[T][];\n}\n\n/**\n * Filter statuses by criteria\n * @param feature - The feature name\n * @param predicate - Function to test each status metadata\n * @returns Array of statuses that match the predicate\n */\nexport function filterStatusesByFeature<T extends StatusFeature>(\n  feature: T,\n  predicate: (metadata: StatusMetadata, status: StatusTypeMap[T]) => boolean,\n): StatusTypeMap[T][] {\n  const metadata = getAllStatusMetadataForFeature(feature);\n  return Object.entries(metadata)\n    .filter(([status, meta]) => predicate(meta as StatusMetadata, status as StatusTypeMap[T]))\n    .map(([status]) => status as StatusTypeMap[T]);\n}\n\n/**\n * Map statuses to a specific value using a transform function\n * @param feature - The feature name\n * @param transform - Function to transform each status metadata\n * @returns Record of statuses mapped to the transformed values\n */\nexport function mapStatusesByFeature<T extends StatusFeature, U>(\n  feature: T,\n  transform: (metadata: StatusMetadata, status: StatusTypeMap[T]) => U,\n): Record<StatusTypeMap[T], U> {\n  const metadata = getAllStatusMetadataForFeature(feature);\n  const result: Record<string, U> = {};\n\n  Object.entries(metadata).forEach(([status, meta]) => {\n    result[status] = transform(meta as StatusMetadata, status as StatusTypeMap[T]);\n  });\n\n  return result as Record<StatusTypeMap[T], U>;\n}\n\n/**\n * Get status metadata with computed properties\n * @param feature - The feature name\n * @param status - The status value\n * @param locale - The language locale\n * @returns Extended metadata with computed labels and description\n */\nexport interface ExtendedStatusMetadata extends Omit<StatusMetadata, 'description'> {\n  shortLabel: string;\n  longLabel: string;\n  description: string;\n}\n\nexport function getExtendedStatusMetadataForFeature<T extends StatusFeature>(\n  feature: T,\n  status: StatusTypeMap[T],\n  locale: Locale = 'us-EN',\n): ExtendedStatusMetadata {\n  const metadata = getStatusMetadataForFeature(feature, status);\n\n  return {\n    icon: metadata.icon,\n    color: metadata.color,\n    label: metadata.label,\n    shortLabel: metadata.label.short[locale],\n    longLabel: metadata.label.long[locale],\n    description: metadata.description[locale],\n  };\n}\n\n/**\n * Search statuses by label\n * @param feature - The feature name\n * @param searchTerm - The search term (case-insensitive)\n * @param locale - The language locale\n * @returns Array of statuses matching the search term\n */\nexport function searchStatusesByFeature<T extends StatusFeature>(\n  feature: T,\n  searchTerm: string,\n  locale: Locale = 'us-EN',\n): StatusTypeMap[T][] {\n  const lowerSearch = searchTerm.toLowerCase();\n\n  return filterStatusesByFeature(feature, (metadata) => {\n    const shortLabel = metadata.label.short[locale].toLowerCase();\n    const longLabel = metadata.label.long[locale].toLowerCase();\n    const description = metadata.description[locale].toLowerCase();\n\n    return shortLabel.includes(lowerSearch) || longLabel.includes(lowerSearch) || description.includes(lowerSearch);\n  });\n}\n\n/**\n * Get status metadata grouped by color\n * @param feature - The feature name\n * @returns Record of colors mapped to arrays of statuses\n */\nexport function groupStatusesByColorForFeature<T extends StatusFeature>(\n  feature: T,\n): Record<string, StatusTypeMap[T][]> {\n  const metadata = getAllStatusMetadataForFeature(feature);\n  const grouped: Record<string, StatusTypeMap[T][]> = {};\n\n  Object.entries(metadata).forEach(([status, meta]) => {\n    const metaTyped = meta as StatusMetadata;\n    if (!grouped[metaTyped.color]) {\n      grouped[metaTyped.color] = [];\n    }\n    grouped[metaTyped.color].push(status as StatusTypeMap[T]);\n  });\n\n  return grouped;\n}\n\n/**\n * Get status metadata grouped by icon\n * @param feature - The feature name\n * @returns Record of icons mapped to arrays of statuses\n */\nexport function groupStatusesByIconForFeature<T extends StatusFeature>(feature: T): Record<string, StatusTypeMap[T][]> {\n  const metadata = getAllStatusMetadataForFeature(feature);\n  const grouped: Record<string, StatusTypeMap[T][]> = {};\n\n  Object.entries(metadata).forEach(([status, meta]) => {\n    const metaTyped = meta as StatusMetadata;\n    if (!grouped[metaTyped.icon]) {\n      grouped[metaTyped.icon] = [];\n    }\n    grouped[metaTyped.icon].push(status as StatusTypeMap[T]);\n  });\n\n  return grouped;\n}\n"]}

package/package.json

@@ -32,7 +32,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.17",
+  "version": "0.0.18",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [