@medyll/idae-be 0.85.0 → 0.86.0

package/dist/modules/dom.js

@@ -15,6 +15,9 @@ var domMethods;
     domMethods["replace"] = "replace";
     domMethods["clear"] = "clear";
 })(domMethods || (domMethods = {}));
+/**
+ * Handles DOM manipulation operations for Be elements.
+ */
 export class DomHandler {
     beElement;
     static methods = Object.values(domMethods);
@@ -64,6 +67,16 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Updates the content of the element(s).
+     * @param content - The new content to set.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.update('<p>Updated content</p>'); // Updates the content of the element
+     */
     update(content, callback) {
         this.beElement.eachNode((el) => {
             if (el) {
@@ -77,6 +90,16 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Appends content to the element(s).
+     * @param content - The content to append (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after appending.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.append('<span>Appended</span>'); // Appends content to the element
+     */
     append(content, callback) {
         const ret = [];
         this.beElement.eachNode((el) => {
@@ -96,6 +119,16 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Prepends content to the element(s).
+     * @param content - The content to prepend (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after prepending.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.prepend('<span>Prepended</span>'); // Prepends content to the element
+     */
     prepend(content, callback) {
         const ret = [];
         this.beElement.eachNode((el) => {
@@ -115,6 +148,17 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Inserts content into the element(s) at a specified position.
+     * @param mode - The position to insert the content ('afterbegin', 'afterend', 'beforebegin', 'beforeend').
+     * @param element - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.insert('afterbegin', '<span>Inserted</span>'); // Inserts content at the beginning
+     */
     insert(mode, element, callback) {
         switch (mode) {
             case 'afterbegin':
@@ -129,6 +173,12 @@ export class DomHandler {
                 throw new Error(`Invalid mode: ${mode}`);
         }
     }
+    /**
+     * Inserts content at the beginning of the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     afterBegin(content, callback) {
         this.beElement.eachNode((el) => {
             this.adjacentElement(el, content, 'afterbegin');
@@ -140,6 +190,12 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Inserts content after the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     afterEnd(content, callback) {
         this.beElement.eachNode((el) => {
             // Insérer après l'élément cible
@@ -152,6 +208,12 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Inserts content before the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     beforeBegin(content, callback) {
         this.beElement.eachNode((el) => {
             // Insérer avant l'élément cible
@@ -164,6 +226,12 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Inserts content at the end of the element(s).
+     * @param content - The content to insert (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after insertion.
+     * @returns The Be instance for method chaining.
+     */
     beforeEnd(content, callback) {
         this.beElement.eachNode((el) => {
             // Insérer à la fin de l'élément cible
@@ -176,6 +244,12 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Replaces the element(s) with new content.
+     * @param content - The content to replace the element(s) with (string, HTMLElement, or Be instance).
+     * @param callback - Optional callback function to execute after replacement.
+     * @returns The Be instance for method chaining.
+     */
     replace(content, callback) {
         const ret = [];
         this.beElement.eachNode((el) => {
@@ -195,6 +269,15 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Removes the element(s) from the DOM.
+     * @param callback - Optional callback function to execute after removal.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"><span>To be removed</span></div>
+     * const beInstance = be('#test span');
+     * beInstance.remove(); // Removes the span element
+     */
     remove(callback) {
         this.beElement.eachNode((el) => {
             el.remove();
@@ -206,6 +289,15 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Clears the content of the element(s).
+     * @param callback - Optional callback function to execute after clearing.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"><span>Content</span></div>
+     * const beInstance = be('#test');
+     * beInstance.clear(); // Clears the content of the div
+     */
     clear(callback) {
         this.beElement.eachNode((el) => {
             const fragment = el.innerHTML;
@@ -218,6 +310,11 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Normalizes the content of the element(s).
+     * @param callback - Optional callback function to execute after normalization.
+     * @returns The Be instance for method chaining.
+     */
     normalize(callback) {
         this.beElement.eachNode((el) => {
             el.normalize();
@@ -229,6 +326,16 @@ export class DomHandler {
         });
         return this.beElement;
     }
+    /**
+     * Wraps the element(s) with a new element.
+     * @param tag - The tag name of the wrapper element (default is 'div').
+     * @param callback - Optional callback function to execute after wrapping.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.wrap('section'); // Wraps the div with a <section> element
+     */
     wrap(tag = 'div', callback) {
         // wrap in tag
         this.beElement.eachNode((el) => {

package/dist/modules/events.d.ts

@@ -35,8 +35,46 @@ export declare class EventsHandler implements CommonHandler<EventsHandler> {
      * @returns The Be instance for method chaining.
      */
     handle(actions: EventHandlerHandle): Be;
+    /**
+     * Adds an event listener to the element(s).
+     * @param eventName - The name of the event to listen for.
+     * @param handler - The event handler function.
+     * @param options - Optional event listener options.
+     * @param callback - Optional callback function to execute after adding the event listener.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.on('click', () => console.log('Clicked!')); // Adds a click event listener
+     */
     on(eventName: string, handler: EventListener, options?: boolean | AddEventListenerOptions, callback?: HandlerCallBackFn): Be;
+    /**
+     * Removes an event listener from the element(s).
+     * @param eventName - The name of the event to remove.
+     * @param handler - The event handler function.
+     * @param options - Optional event listener options.
+     * @param callback - Optional callback function to execute after removing the event listener.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * const handler = () => console.log('Clicked!');
+     * beInstance.on('click', handler); // Adds a click event listener
+     * beInstance.off('click', handler); // Removes the click event listener
+     */
     off(eventName: string, handler: EventListener, options?: boolean | AddEventListenerOptions, callback?: HandlerCallBackFn): Be;
+    /**
+     * Dispatches a custom event on the element(s).
+     * @param eventName - The name of the custom event to dispatch.
+     * @param detail - Optional data to include in the event.
+     * @param options - Optional event initialization options.
+     * @param callback - Optional callback function to execute after dispatching the event.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.fire('customEvent', { key: 'value' }); // Dispatches a custom event with data
+     */
     fire(eventName: string, detail: unknown, options?: EventInit, callback?: HandlerCallBackFn): Be;
 }
 export {};

package/dist/modules/events.js

@@ -34,6 +34,18 @@ export class EventsHandler {
         });
         return this.beElement;
     }
+    /**
+     * Adds an event listener to the element(s).
+     * @param eventName - The name of the event to listen for.
+     * @param handler - The event handler function.
+     * @param options - Optional event listener options.
+     * @param callback - Optional callback function to execute after adding the event listener.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.on('click', () => console.log('Clicked!')); // Adds a click event listener
+     */
     on(eventName, handler, options, callback) {
         this.beElement.eachNode((el) => {
             el.addEventListener(eventName, handler, options);
@@ -45,6 +57,20 @@ export class EventsHandler {
         });
         return this.beElement;
     }
+    /**
+     * Removes an event listener from the element(s).
+     * @param eventName - The name of the event to remove.
+     * @param handler - The event handler function.
+     * @param options - Optional event listener options.
+     * @param callback - Optional callback function to execute after removing the event listener.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * const handler = () => console.log('Clicked!');
+     * beInstance.on('click', handler); // Adds a click event listener
+     * beInstance.off('click', handler); // Removes the click event listener
+     */
     off(eventName, handler, options, callback) {
         this.beElement.eachNode((el) => {
             el.removeEventListener(eventName, handler, options);
@@ -56,6 +82,18 @@ export class EventsHandler {
         });
         return this.beElement;
     }
+    /**
+     * Dispatches a custom event on the element(s).
+     * @param eventName - The name of the custom event to dispatch.
+     * @param detail - Optional data to include in the event.
+     * @param options - Optional event initialization options.
+     * @param callback - Optional callback function to execute after dispatching the event.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.fire('customEvent', { key: 'value' }); // Dispatches a custom event with data
+     */
     fire(eventName, detail, options, callback) {
         this.beElement.eachNode((el) => {
             el.dispatchEvent(new CustomEvent(eventName, { ...options, detail }));

package/dist/modules/position.d.ts

@@ -27,12 +27,17 @@ export declare class PositionHandler implements CommonHandler<PositionHandler, P
     handle(actions: PositionHandlerHandle): Be;
     /**
      * Clones the position of a source element to this element.
-     * @param source The element or selector of the element whose position is to be cloned.
-     * @param options Additional options for positioning.
-     * @param options.offsetX Horizontal offset from the source position.
-     * @param options.offsetY Vertical offset from the source position.
-     * @param options.useTransform Whether to use CSS transform for positioning.
+     * @param source - The element or selector of the element whose position is to be cloned.
+     * @param options - Additional options for positioning.
+     * @param options.offsetX - Horizontal offset from the source position.
+     * @param options.offsetY - Vertical offset from the source position.
+     * @param options.useTransform - Whether to use CSS transform for positioning.
+     * @param callback - Optional callback function to execute after cloning the position.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="source"></div><div id="target"></div>
+     * const beInstance = be('#target');
+     * beInstance.clonePosition('#source', { offsetX: 10, offsetY: 20 });
      */
     clonePosition(source: string | HTMLElement, options?: {
         offsetX?: number;
@@ -41,12 +46,17 @@ export declare class PositionHandler implements CommonHandler<PositionHandler, P
     }, callback?: HandlerCallBackFn): Be;
     /**
      * Positions this element to overlap a target element.
-     * @param targetElement The element or selector of the element to overlap.
-     * @param options Additional options for positioning.
-     * @param options.alignment The alignment of this element relative to the target.
-     * @param options.offset The distance to offset from the target element.
-     * @param options.useTransform Whether to use CSS transform for positioning.
+     * @param targetElement - The element or selector of the element to overlap.
+     * @param options - Additional options for positioning.
+     * @param options.alignment - The alignment of this element relative to the target.
+     * @param options.offset - The distance to offset from the target element.
+     * @param options.useTransform - Whether to use CSS transform for positioning.
+     * @param callback - Optional callback function to execute after positioning.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="source"></div><div id="target"></div>
+     * const beInstance = be('#target');
+     * beInstance.overlapPosition('#source', { alignment: 'center', offset: 10 });
      */
     overlapPosition(targetElement: string | HTMLElement, options?: {
         alignment?: 'center' | 'top' | 'bottom' | 'left' | 'right';
@@ -55,12 +65,21 @@ export declare class PositionHandler implements CommonHandler<PositionHandler, P
     }, callback?: HandlerCallBackFn): Be;
     /**
      * Snaps the element to a target element with specified anchor points.
-     * @param targetElement The element or selector of the element to snap to.
-     * @param options Snapping options.
-     * @param options.sourceAnchor The anchor point on the source element.
-     * @param options.targetAnchor The anchor point on the target element.
-     * @param options.offset Optional offset from the target anchor point.
+     * @param targetElement - The element or selector of the element to snap to.
+     * @param options - Snapping options.
+     * @param options.sourceAnchor - The anchor point on the source element.
+     * @param options.targetAnchor - The anchor point on the target element.
+     * @param options.offset - Optional offset from the target anchor point.
+     * @param callback - Optional callback function to execute after snapping.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="source"></div><div id="target"></div>
+     * const beInstance = be('#target');
+     * beInstance.snapTo('#source', {
+     *   sourceAnchor: 'center',
+     *   targetAnchor: 'top left',
+     *   offset: { x: 10, y: 20 }
+     * });
      */
     snapTo(targetElement: string | HTMLElement, options: {
         sourceAnchor: PositionSnapOptions;

package/dist/modules/position.js

@@ -31,12 +31,17 @@ export class PositionHandler {
     }
     /**
      * Clones the position of a source element to this element.
-     * @param source The element or selector of the element whose position is to be cloned.
-     * @param options Additional options for positioning.
-     * @param options.offsetX Horizontal offset from the source position.
-     * @param options.offsetY Vertical offset from the source position.
-     * @param options.useTransform Whether to use CSS transform for positioning.
+     * @param source - The element or selector of the element whose position is to be cloned.
+     * @param options - Additional options for positioning.
+     * @param options.offsetX - Horizontal offset from the source position.
+     * @param options.offsetY - Vertical offset from the source position.
+     * @param options.useTransform - Whether to use CSS transform for positioning.
+     * @param callback - Optional callback function to execute after cloning the position.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="source"></div><div id="target"></div>
+     * const beInstance = be('#target');
+     * beInstance.clonePosition('#source', { offsetX: 10, offsetY: 20 });
      */
     clonePosition(source, options = {}, callback) {
         if (this.beElement.isWhat !== 'element')
@@ -68,12 +73,17 @@ export class PositionHandler {
     }
     /**
      * Positions this element to overlap a target element.
-     * @param targetElement The element or selector of the element to overlap.
-     * @param options Additional options for positioning.
-     * @param options.alignment The alignment of this element relative to the target.
-     * @param options.offset The distance to offset from the target element.
-     * @param options.useTransform Whether to use CSS transform for positioning.
+     * @param targetElement - The element or selector of the element to overlap.
+     * @param options - Additional options for positioning.
+     * @param options.alignment - The alignment of this element relative to the target.
+     * @param options.offset - The distance to offset from the target element.
+     * @param options.useTransform - Whether to use CSS transform for positioning.
+     * @param callback - Optional callback function to execute after positioning.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="source"></div><div id="target"></div>
+     * const beInstance = be('#target');
+     * beInstance.overlapPosition('#source', { alignment: 'center', offset: 10 });
      */
     overlapPosition(targetElement, options = {}, callback) {
         if (this.beElement.isWhat !== 'element')
@@ -125,12 +135,21 @@ export class PositionHandler {
     }
     /**
      * Snaps the element to a target element with specified anchor points.
-     * @param targetElement The element or selector of the element to snap to.
-     * @param options Snapping options.
-     * @param options.sourceAnchor The anchor point on the source element.
-     * @param options.targetAnchor The anchor point on the target element.
-     * @param options.offset Optional offset from the target anchor point.
+     * @param targetElement - The element or selector of the element to snap to.
+     * @param options - Snapping options.
+     * @param options.sourceAnchor - The anchor point on the source element.
+     * @param options.targetAnchor - The anchor point on the target element.
+     * @param options.offset - Optional offset from the target anchor point.
+     * @param callback - Optional callback function to execute after snapping.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="source"></div><div id="target"></div>
+     * const beInstance = be('#target');
+     * beInstance.snapTo('#source', {
+     *   sourceAnchor: 'center',
+     *   targetAnchor: 'top left',
+     *   offset: { x: 10, y: 20 }
+     * });
      */
     snapTo(targetElement, options, callback) {
         if (this.beElement.isWhat !== 'element')
@@ -146,7 +165,6 @@ export class PositionHandler {
         // Calculate final position
         const x = targetX - sourceX + offset.x;
         const y = targetY - sourceY + offset.y;
-        console.log('Calculated position:', { x, y }, [sourceX, sourceY], { sourceRect });
         // Apply position
         this.beElement.eachNode((el) => {
             const computedStyle = window.getComputedStyle(el);

package/dist/modules/styles.d.ts

@@ -20,19 +20,38 @@ export declare class StylesHandler implements CommonHandler<StylesHandler> {
     handle(actions: BeStylesHandler): Be;
     private resolveIndirection;
     /**
-     * setStyle Sets one or more CSS styles for the selected element(s), including CSS custom properties.
-     * @param styles An object of CSS properties and values, or a string of CSS properties and values.
-     * @param value The value for a single CSS property when styles is a property name string.
+     * Sets one or more CSS styles for the selected element(s), including CSS custom properties.
+     * @param styles - An object of CSS properties and values, or a string of CSS properties and values.
+     * @param value - The value for a single CSS property when styles is a property name string.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.setStyle({ color: 'red', backgroundColor: 'blue' }); // Sets multiple styles
+     * beInstance.setStyle('color', 'green'); // Sets a single style
      */
     set(styles: Record<string, string> | string, value?: string): Be;
     /**
-     * getStyle Gets the value of a CSS property for the first matched element.
-     * @param key The CSS property name.
+     * Gets the value of a CSS property for the first matched element.
+     * @param key - The CSS property name.
      * @returns The value of the CSS property, or null if not found.
+     * @example
+     * // HTML: <div id="test" style="color: red;"></div>
+     * const beInstance = be('#test');
+     * const color = beInstance.getStyle('color');
+     * console.log(color); // Output: "red"
      */
     get(key: string): string | null;
-    unset(key: string): string | null;
+    /**
+     * Removes a CSS property from the selected element(s).
+     * @param key - The CSS property name to remove.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" style="color: red;"></div>
+     * const beInstance = be('#test');
+     * beInstance.unsetStyle('color'); // Removes the "color" style
+     */
+    unset(key: string): Be;
     private applyStyle;
     getKey(key: string): string | null;
 }

package/dist/modules/styles.js

@@ -63,10 +63,15 @@ export class StylesHandler {
         return { method: method, args };
     }
     /**
-     * setStyle Sets one or more CSS styles for the selected element(s), including CSS custom properties.
-     * @param styles An object of CSS properties and values, or a string of CSS properties and values.
-     * @param value The value for a single CSS property when styles is a property name string.
+     * Sets one or more CSS styles for the selected element(s), including CSS custom properties.
+     * @param styles - An object of CSS properties and values, or a string of CSS properties and values.
+     * @param value - The value for a single CSS property when styles is a property name string.
      * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test"></div>
+     * const beInstance = be('#test');
+     * beInstance.setStyle({ color: 'red', backgroundColor: 'blue' }); // Sets multiple styles
+     * beInstance.setStyle('color', 'green'); // Sets a single style
      */
     set(styles, value) {
         if (typeof styles === 'string') {
@@ -90,9 +95,14 @@ export class StylesHandler {
         return this.beElement;
     }
     /**
-     * getStyle Gets the value of a CSS property for the first matched element.
-     * @param key The CSS property name.
+     * Gets the value of a CSS property for the first matched element.
+     * @param key - The CSS property name.
      * @returns The value of the CSS property, or null if not found.
+     * @example
+     * // HTML: <div id="test" style="color: red;"></div>
+     * const beInstance = be('#test');
+     * const color = beInstance.getStyle('color');
+     * console.log(color); // Output: "red"
      */
     get(key) {
         let css = null;
@@ -107,12 +117,20 @@ export class StylesHandler {
         }, true);
         return css || null;
     }
-    // unset style
+    /**
+     * Removes a CSS property from the selected element(s).
+     * @param key - The CSS property name to remove.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test" style="color: red;"></div>
+     * const beInstance = be('#test');
+     * beInstance.unsetStyle('color'); // Removes the "color" style
+     */
     unset(key) {
         this.beElement.eachNode((el) => {
             el.style.removeProperty(key);
         });
-        return null;
+        return this.beElement;
     }
     applyStyle(property, value) {
         this.beElement.eachNode((el) => {

package/dist/modules/text.d.ts

@@ -28,13 +28,90 @@ export declare class TextHandler implements CommonHandler<TextHandler> {
     methods: string[] | keyof TextHandler;
     get text(): string | null;
     handle(actions: TextHandlerHandle): Be;
+    /**
+     * Updates the text content of the element(s).
+     * @param content - The new text content to set.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">Original</div>
+     * const beInstance = be('#test');
+     * beInstance.updateText('Updated'); // Updates the text content to "Updated"
+     */
     update(content: TextHandlerHandle['update'], callback?: HandlerCallBackFn): Be;
+    /**
+     * Appends text content to the element(s).
+     * @param content - The text content to append.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">Original</div>
+     * const beInstance = be('#test');
+     * beInstance.appendText(' Appended'); // Appends " Appended" to the text content
+     */
     append(content: TextHandlerHandle['append'], callback?: HandlerCallBackFn): Be;
+    /**
+     * Prepends text content to the element(s).
+     * @param content - The text content to prepend.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">Original</div>
+     * const beInstance = be('#test');
+     * beInstance.prependText('Prepended '); // Prepends "Prepended " to the text content
+     */
     prepend(content: TextHandlerHandle['prepend'], callback?: HandlerCallBackFn): Be;
+    /**
+     * Replaces the text content of the element(s).
+     * @param content - The new text content to replace with.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">Original</div>
+     * const beInstance = be('#test');
+     * beInstance.replaceText('Replaced'); // Replaces the text content with "Replaced"
+     */
     replace(content: TextHandlerHandle['replace'], callback?: HandlerCallBackFn): Be;
+    /**
+     * Removes the element(s) from the DOM.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">To be removed</div>
+     * const beInstance = be('#test');
+     * beInstance.removeText(); // Removes the element
+     */
     remove(callback?: HandlerCallBackFn): Be;
+    /**
+     * Clears the text content of the element(s).
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">Content</div>
+     * const beInstance = be('#test');
+     * beInstance.clearText(); // Clears the text content
+     */
     clear(callback?: HandlerCallBackFn): Be;
+    /**
+     * Normalizes the text content of the element(s).
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">Text <span>Fragment</span> Text</div>
+     * const beInstance = be('#test');
+     * beInstance.normalizeText(); // Normalizes the text content
+     */
     normalize(callback?: HandlerCallBackFn): Be;
+    /**
+     * Wraps the element(s) with a new element.
+     * @param content - The wrapper element as a string or HTMLElement.
+     * @param callback - Optional callback function.
+     * @returns The Be instance for method chaining.
+     * @example
+     * // HTML: <div id="test">Content</div>
+     * const beInstance = be('#test');
+     * beInstance.wrapText('<div class="wrapper"></div>'); // Wraps the element with a <div>
+     */
     wrap(content: TextHandlerHandle['wrap'], callback?: HandlerCallBackFn): Be;
     valueOf(): string | null;
 }