genesys-spark-components 4.231.2 → 4.232.1

package/dist/types/utils/dom/slot-cache.d.ts

@@ -0,0 +1,105 @@
+/**
+ * A cache for slot elements to avoid repeated DOM queries.
+ *
+ * This utility helps optimize components that frequently access the same slots
+ * by caching the slot elements after the first query.
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   private slotCache = createSlotCache();
+ *
+ *   get headerSlot(): Element | null {
+ *     return this.slotCache.get(this.root, 'header');
+ *   }
+ *
+ *   get footerSlot(): Element | null {
+ *     return this.slotCache.get(this.root, 'footer');
+ *   }
+ *
+ *   disconnectedCallback() {
+ *     this.slotCache.clear();
+ *   }
+ * }
+ * ```
+ */
+export interface SlotCache {
+    /**
+     * Get a slot element, using cache if available.
+     * @param element - The parent element containing the slot
+     * @param slotName - The name of the slot to retrieve
+     * @returns The slot element or null if not found
+     */
+    get(element: HTMLElement, slotName: string): Element | null;
+    /**
+     * Check if a slot is cached.
+     * @param slotName - The name of the slot to check
+     * @returns True if the slot is in the cache
+     */
+    has(slotName: string): boolean;
+    /**
+     * Manually set a slot in the cache.
+     * @param slotName - The name of the slot
+     * @param element - The slot element (or null)
+     */
+    set(slotName: string, element: Element | null): void;
+    /**
+     * Remove a specific slot from the cache.
+     * Useful when you know a slot has changed.
+     * @param slotName - The name of the slot to invalidate
+     */
+    invalidate(slotName: string): void;
+    /**
+     * Clear all cached slots.
+     * Should be called in disconnectedCallback to prevent memory leaks.
+     */
+    clear(): void;
+    /**
+     * Get the number of cached slots.
+     */
+    size(): number;
+}
+/**
+ * Create a new slot cache instance.
+ *
+ * @returns A new SlotCache instance
+ *
+ * @example
+ * ```typescript
+ * // In your component
+ * private slotCache = createSlotCache();
+ *
+ * get mySlot(): Element | null {
+ *   return this.slotCache.get(this.root, 'my-slot');
+ * }
+ *
+ * disconnectedCallback() {
+ *   this.slotCache.clear();
+ * }
+ * ```
+ */
+export declare function createSlotCache(): SlotCache;
+/**
+ * A decorator-based approach for caching slots.
+ * This provides a more declarative way to cache slots using TypeScript decorators.
+ *
+ * @param slotName - The name of the slot to cache
+ * @returns A property decorator
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   @Element() root: HTMLElement;
+ *   private slotCache = createSlotCache();
+ *
+ *   @CachedSlot('header')
+ *   get headerSlot(): Element | null {
+ *     return this.slotCache.get(this.root, 'header');
+ *   }
+ * }
+ * ```
+ *
+ * Note: This is an advanced pattern. The simple createSlotCache() approach
+ * is recommended for most use cases.
+ */
+export declare function CachedSlot(slotName: string): (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/types/utils/function/debounce.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until after
+ * the specified delay has elapsed since the last time the debounced function was invoked.
+ *
+ * This is a lightweight implementation focused on the most common use case.
+ * For more advanced features (leading edge, maxWait, etc.), consider using lodash.debounce.
+ *
+ * @param func - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced version of the function with cancel() method
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const debouncedSave = debounce(() => {
+ *   console.log('Saving...');
+ * }, 500);
+ *
+ * debouncedSave(); // Will execute after 500ms
+ * debouncedSave(); // Cancels previous, will execute after 500ms
+ *
+ * // With cancel
+ * const debounced = debounce(() => console.log('Done'), 500);
+ * debounced();
+ * debounced.cancel(); // Cancel pending execution
+ * ```
+ */
+export interface DebouncedFunction<T extends (...args: unknown[]) => unknown> {
+    /**
+     * Call the debounced function
+     */
+    (...args: Parameters<T>): void;
+    /**
+     * Cancel any pending execution
+     */
+    cancel(): void;
+}
+/**
+ * Create a debounced function.
+ *
+ * @param func - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced function with cancel() method
+ */
+export declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, delay: number): DebouncedFunction<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesys-spark-components",
-  "version": "4.231.2",
+  "version": "4.232.1",
   "description": "Common webcomponents",
   "license": "MIT",
   "main": "dist/stencil-wrapper.js",