@medyll/idae-be 0.83.0 → 0.85.0

package/dist/be.js

@@ -127,7 +127,7 @@ export class Be {
         // position
         this.positionHandler = new PositionHandler(this);
         this.position = this.handle(this.positionHandler);
-        this.attach(PositionHandler, 'Position');
+        this.attach(PositionHandler);
         // text
         this.textHandler = new TextHandler(this);
         this.dom = this.handle(this.textHandler);
@@ -306,11 +306,14 @@ export class Be {
         const fromMethods = Handler.methods || [];
         fromMethods.forEach((method) => {
             const handler = new Handler(this);
-            const methodName = method + suffix;
+            const methodName = suffix ? method + suffix : method;
             if (!(method in handler)) {
                 console.error(`Method ${method} not found in ${Handler.name}`, handler);
             }
             else if (methodName in this) {
+                if (!handler) {
+                    console.error(`Handler ${Handler.name} not found`, handler);
+                }
                 this[methodName] = (...args) => {
                     return handler[method].apply(handler, args);
                 };

package/dist/modules/attrs.d.ts

@@ -7,7 +7,8 @@ declare enum attrMethods {
 }
 export type AttrHandlerHandle = {
     set: AttrHandler['set'];
-    delete: AttrHandler['handle'];
+    get: AttrHandler['get'];
+    delete: AttrHandler['delete'];
 };
 export declare class AttrHandler implements CommonHandler<AttrHandler, AttrHandler> {
     private beElement;

package/dist/modules/attrs.js

@@ -12,12 +12,23 @@ export class AttrHandler {
         this.beElement = element;
     }
     handle(actions) {
-        this.beElement.eachNode((el) => {
+        Object.entries(actions).forEach(([method, props]) => {
+            switch (method) {
+                case 'set':
+                    this.set(props);
+                    break;
+                case 'delete':
+                    this.delete(props);
+                    break;
+            }
+        });
+        /* this.beElement.eachNode((el) => {
             if (actions.delete) {
+                this.delete(actions.delete);
             }
             if (actions.set) {
             }
-        });
+        }); */
         return this.beElement;
     }
     get(name) {

package/dist/modules/position.d.ts

@@ -62,8 +62,7 @@ export declare class PositionHandler implements CommonHandler<PositionHandler, P
      * @param options.offset Optional offset from the target anchor point.
      * @returns The Be instance for method chaining.
      */
-    snapTo(targetElement: string | HTMLElement, // SnapToOptions
-    options: {
+    snapTo(targetElement: string | HTMLElement, options: {
         sourceAnchor: PositionSnapOptions;
         targetAnchor: PositionSnapOptions;
         offset?: {

package/dist/modules/position.js

@@ -132,8 +132,7 @@ export class PositionHandler {
      * @param options.offset Optional offset from the target anchor point.
      * @returns The Be instance for method chaining.
      */
-    snapTo(targetElement, // SnapToOptions
-    options, callback) {
+    snapTo(targetElement, options, callback) {
         if (this.beElement.isWhat !== 'element')
             return this.beElement;
         const targetEl = typeof targetElement === 'string' ? document.querySelector(targetElement) : targetElement;
@@ -147,6 +146,7 @@ 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/types.d.ts

@@ -1,12 +1,12 @@
 import { Be } from './be.js';
-export type CombineElements<T extends string> = T extends any ? T | `${T} ${CombineElements<T>}` : never;
+export type CombineElements<T extends string> = T extends unknown ? T | `${T} ${CombineElements<T>}` : never;
 export type IsWhat = 'element' | 'array' | 'qy';
-export type PositionSnapOptions = 'top' | 'right' | 'bottom' | 'left' | `${'top' | 'right' | 'bottom' | 'left'} center` | 'center';
+export type PositionSnapOptions = 'top' | 'right' | 'bottom' | 'left' | 'center' | `${'top' | 'bottom'} ${'left' | 'right' | 'center'}` | `${'left' | 'right'} ${'top' | 'bottom' | 'center'}`;
 export type HandlerCallbackProps = {
     be: Be;
-    fragment: any;
+    fragment: unknown;
     root: Be;
-    requested?: any;
+    requested?: unknown;
     method?: string;
 };
 export type HandlerCallBackFn = (element: HandlerCallbackProps) => void;
@@ -16,7 +16,7 @@ export type HandlerCallBack = {
 export type ExpandTyping<T> = T extends infer O ? {
     [K in keyof O]: O[K];
 } : never;
-export interface CommonHandler<T = any, H = any, V = unknown> {
+export interface CommonHandler<T = unknown, H = unknown, V = unknown> {
     handle: (actions: H) => Be;
     methods: string[] | keyof T;
     valueOf: () => V;

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import { type Be } from './be.js';
-import type { CommonHandler } from './types.js';
+import type { CommonHandler, PositionSnapOptions } from './types.js';
 interface isHTMLReturn {
     isHtml: boolean;
     tag: string;
@@ -18,7 +18,7 @@ export declare class BeUtils {
         returnHTMLelement?: boolean;
         transformTextToHtml?: boolean;
     }): isHTMLReturn;
-    static calculateAnchorPoint(rect: DOMRect, anchor: string): [number, number];
+    static calculateAnchorPoint(rect: DOMRect, anchor: PositionSnapOptions): [number, number];
     static applyStyle(beElement: Be, property: string, value: string): void;
     static applyCallback(el: HTMLElement | HTMLCollection, callback: (el: HTMLElement) => void): void;
     static resolveIndirection<T = CommonHandler>(classHandler: CommonHandler, actions: keyof T): {

package/dist/utils.js

@@ -62,33 +62,36 @@ export class BeUtils {
         return result;
     }
     static calculateAnchorPoint(rect, anchor) {
-        const [vertical, horizontal] = anchor.split(' ');
-        let x, y;
-        switch (vertical) {
-            case 'top':
-                y = rect.top;
-                break;
-            case 'bottom':
-                y = rect.bottom;
-                break;
-            case 'center':
-                y = rect.top + rect.height / 2;
-                break;
-            default:
-                y = rect.top;
+        let x = rect.left; // Valeur par défaut pour x
+        let y = rect.top; // Valeur par défaut pour y
+        if (typeof anchor === 'string') {
+            const [vertical, horizontal] = anchor.split(' ');
+            switch (vertical) {
+                case 'top':
+                    y = rect.top;
+                    break;
+                case 'bottom':
+                    y = rect.bottom;
+                    break;
+                case 'center':
+                    y = rect.top + rect.height / 2;
+                    x = rect.left + rect.width / 2;
+                    break;
+            }
+            switch (horizontal) {
+                case 'left':
+                    x = rect.left;
+                    break;
+                case 'right':
+                    x = rect.right;
+                    break;
+                case 'center':
+                    x = rect.left + rect.width / 2;
+                    break;
+            }
         }
-        switch (horizontal) {
-            case 'left':
-                x = rect.left;
-                break;
-            case 'right':
-                x = rect.right;
-                break;
-            case 'center':
-                x = rect.left + rect.width / 2;
-                break;
-            default:
-                x = rect.left;
+        else {
+            throw new Error('Invalid anchor type. Expected a string.');
         }
         return [x, y];
     }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@medyll/idae-be",
 	"scope": "@medyll",
-	"version": "0.83.0",
+	"version": "0.85.0",
 	"description": "A powerful DOM manipulation library with a callback-based approach for precise element targeting. Provides consistent chaining, comprehensive DOM traversal, event handling, style management, and more. Written in TypeScript for modern browsers.",
 	"scripts": {
 		"dev": "vite dev",