@medyll/idae-be 0.82.0 → 0.84.0

package/dist/be.d.ts

@@ -4,7 +4,6 @@ import type { IsWhat } from './types.js';
 import { type DataHandlerHandle, DataHandler } from './modules/data.js';
 import { EventsHandler, type EventHandlerHandle } from './modules/events.js';
 import { type ClassHandlerHandler, ClassesHandler } from './modules/classes.js';
-import { type PropsHandlerHandle } from './modules/props.js';
 import { DomHandler, type DomHandlerHandle } from './modules/dom.js';
 import { PositionHandler, type PositionHandlerHandle } from './modules/position.js';
 import { WalkHandler } from './modules/walk.js';
@@ -13,15 +12,13 @@ import { TimersHandler } from './modules/timers.js';
 export declare class Be {
     inputNode: HTMLElement | HTMLElement[] | string;
     isWhat: IsWhat;
-    BeTimer: NodeJS.Timeout | null;
-    BeInterval: NodeJS.Timeout | null;
+    timerOut: NodeJS.Timeout | null;
+    timerInterval: NodeJS.Timeout | null;
     styles: (actions: BeStylesHandler) => Be;
     private styleHandler;
     setStyle: StylesHandler['set'];
     getStyle: StylesHandler['get'];
     unsetStyle: StylesHandler['unset'];
-    props: (actions: PropsHandlerHandle) => Be;
-    private propHandler;
     data: (actions: DataHandlerHandle) => Be;
     private dataHandler;
     setData: DataHandler['set'];

package/dist/be.js

@@ -4,7 +4,6 @@ import { BeUtils } from './utils.js';
 import { DataHandler } from './modules/data.js';
 import { EventsHandler } from './modules/events.js';
 import { ClassesHandler } from './modules/classes.js';
-import { PropsHandler } from './modules/props.js';
 import { DomHandler } from './modules/dom.js';
 import { PositionHandler } from './modules/position.js';
 import { WalkHandler } from './modules/walk.js';
@@ -14,17 +13,14 @@ export class Be {
     inputNode;
     isWhat;
     //
-    BeTimer = null;
-    BeInterval = null;
+    timerOut = null;
+    timerInterval = null;
     // styles
     styles;
     styleHandler;
     setStyle;
     getStyle;
     unsetStyle;
-    // properties
-    props;
-    propHandler;
     // dataSet
     data;
     dataHandler;
@@ -120,10 +116,6 @@ export class Be {
         this.styleHandler = new StylesHandler(this);
         this.styles = this.handle(this.styleHandler);
         this.attach(StylesHandler, 'Style');
-        // properties
-        this.propHandler = new PropsHandler(this);
-        this.props = this.handle(this.styleHandler);
-        this.attach(PropsHandler, 'Prop');
         // dataSet
         this.dataHandler = new DataHandler(this);
         this.data = this.handle(this.styleHandler);
@@ -135,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);
@@ -314,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/index.d.ts

@@ -5,7 +5,6 @@ export * from './modules/walk.js';
 export * from './modules/timers.js';
 export * from './modules/text.js';
 export * from './modules/styles.js';
-export * from './modules/props.js';
 export * from './modules/position.js';
 export * from './modules/events.js';
 export * from './modules/dom.js';

package/dist/index.js

@@ -6,7 +6,6 @@ export * from './modules/walk.js';
 export * from './modules/timers.js';
 export * from './modules/text.js';
 export * from './modules/styles.js';
-export * from './modules/props.js';
 export * from './modules/position.js';
 export * from './modules/events.js';
 export * from './modules/dom.js';

package/dist/modules/attrs.js

@@ -47,7 +47,7 @@ export class AttrHandler {
                 el.removeAttribute(nameOrObject);
             }
             else if (typeof nameOrObject === 'object') {
-                Object.entries(nameOrObject).forEach(([name, val]) => {
+                Object.entries(nameOrObject).forEach(([name]) => {
                     el.removeAttribute(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/modules/text.js

@@ -34,7 +34,7 @@ export class TextHandler {
                     break;
                 case 'prepend':
                     if (typeof props === 'string') {
-                        el.insertAdjacentHTML('afterbegin', props);
+                        el.insertAdjacentText('afterbegin', props);
                     }
                     else {
                         throw new Error('Invalid props for prepend: must be a string.');
@@ -42,7 +42,7 @@ export class TextHandler {
                     break;
                 case 'append':
                     if (typeof props === 'string') {
-                        el.insertAdjacentHTML('beforeend', props);
+                        el.insertAdjacentText('beforeend', props);
                     }
                     else {
                         throw new Error('Invalid props for append: must be a string.');
@@ -50,7 +50,7 @@ export class TextHandler {
                     break;
                 case 'replace':
                     if (typeof props === 'string') {
-                        el.outerHTML = props;
+                        el.textContent = props;
                     }
                     else {
                         throw new Error('Invalid props for replace: must be a string.');

package/dist/modules/timers.d.ts

@@ -10,10 +10,9 @@ type cd = Record<'timeout' | 'interval', number> & HandlerCallBack;
 type cds = Record<'clearTimeout' | 'clearInterval', HandlerCallBackFn>;
 type TimerHandlerHandle = cd & cds;
 export declare class TimersHandler implements CommonHandler<TimersHandler> {
+    #private;
     private beElement;
     static methods: timersMethods[];
-    _timer: NodeJS.Timeout | null;
-    _interval: NodeJS.Timeout | null;
     constructor(element: Be);
     methods: string[] | keyof TimersHandler;
     valueOf(): unknown;

package/dist/modules/timers.js

@@ -9,8 +9,8 @@ var timersMethods;
 export class TimersHandler {
     beElement;
     static methods = Object.values(timersMethods);
-    _timer = null;
-    _interval = null;
+    #timer = null;
+    #interval = null;
     constructor(element) {
         this.beElement = element;
     }
@@ -18,8 +18,8 @@ export class TimersHandler {
     valueOf() {
         return {
             methods: this.methods,
-            timer: this._timer,
-            interval: this._interval
+            timer: this.#timer,
+            interval: this.#interval
         };
     }
     handle(actions) {
@@ -40,10 +40,10 @@ export class TimersHandler {
         return this.beElement;
     }
     timeout(value, callback) {
-        this.beElement.BeTimer = setTimeout(() => {
+        this.beElement.timerOut = setTimeout(() => {
             callback?.({
                 method: 'timeout',
-                fragment: this.beElement.BeTimer,
+                fragment: this.beElement.timerOut,
                 be: this.beElement,
                 root: this.beElement
             });
@@ -62,10 +62,10 @@ export class TimersHandler {
         return this.beElement;
     }
     interval(value, callback) {
-        this.beElement.BeInterval = setInterval(() => {
+        this.beElement.timerInterval = setInterval(() => {
             callback?.({
                 method: 'interval',
-                fragment: this.beElement.BeInterval,
+                fragment: this.beElement.timerInterval,
                 be: this.beElement,
                 root: this.beElement
             });
@@ -84,8 +84,9 @@ export class TimersHandler {
         return this.beElement;
     }
     clearTimeout(callback) {
-        clearTimeout(this.beElement?.BeTimer);
-        this.beElement.BeTimer = null;
+        if (this.beElement.timerOut)
+            clearTimeout(this.beElement.timerOut);
+        this.beElement.timerOut = null;
         /* this.beElement.eachNode((el: HTMLElement) => {
             const aug = be(el);
             if (aug.BeTimer !== null) {
@@ -102,8 +103,9 @@ export class TimersHandler {
         return this.beElement;
     }
     clearInterval(callback) {
-        clearInterval(this.beElement?.BeInterval);
-        this.beElement.BeInterval = null;
+        if (this.beElement.timerInterval)
+            clearInterval(this.beElement.timerInterval);
+        this.beElement.timerInterval = null;
         /* this.beElement.eachNode((el: HTMLElement) => {
             const aug = be(el);
             if (aug.BeInterval !== null) {

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.82.0",
+	"version": "0.84.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",

package/dist/modules/props.d.ts

@@ -1,29 +0,0 @@
-import { Be } from '../be.js';
-import type { CommonHandler, HandlerCallBack, HandlerCallBackFn } from '../types.js';
-declare enum PropsMethods {
-    set = "set",
-    get = "get",
-    delete = "delete",
-    getKey = "getKey"
-}
-export interface PropsHandlerHandle {
-    set?: {
-        [key: string]: unknown;
-    } & HandlerCallBack;
-    delete?: {
-        keys: string[];
-    } & HandlerCallBack;
-}
-export declare class PropsHandler implements CommonHandler<PropsHandler, PropsHandlerHandle> {
-    private beElement;
-    static methods: PropsMethods[];
-    constructor(beElement: Be);
-    methods: (keyof PropsHandler)[];
-    handle(actions: PropsHandlerHandle): Be;
-    get(name: string, callback?: HandlerCallBackFn): any;
-    set(nameOrObject: string | Record<string, any>, value?: any, callback?: HandlerCallBackFn): Be;
-    delete(name: string, callback?: HandlerCallBackFn): Be;
-    getKey(key: string, callback?: HandlerCallBackFn): string | null;
-    valueOf(): Record<string, any> | null;
-}
-export {};

package/dist/modules/props.js

@@ -1,68 +0,0 @@
-import { Be } from '../be.js';
-var PropsMethods;
-(function (PropsMethods) {
-    PropsMethods["set"] = "set";
-    PropsMethods["get"] = "get";
-    PropsMethods["delete"] = "delete";
-    PropsMethods["getKey"] = "getKey";
-})(PropsMethods || (PropsMethods = {}));
-export class PropsHandler {
-    beElement;
-    static methods = Object.values(PropsMethods);
-    constructor(beElement) {
-        this.beElement = beElement;
-    }
-    methods = PropsHandler.methods;
-    handle(actions) {
-        if (!actions)
-            return this.beElement;
-        Object.entries(actions).forEach(([method, props]) => {
-            switch (method) {
-                case 'set':
-                    {
-                        const [key, val] = Object.entries(props)[0];
-                        this.set(key, val, props.callback);
-                    }
-                    break;
-                case 'delete':
-                    this.delete(props.delete);
-                    break;
-            }
-        });
-        return this.beElement;
-    }
-    get(name, callback) {
-        if (this.beElement.isWhat !== 'element')
-            return null;
-        return this.beElement.inputNode[name];
-    }
-    set(nameOrObject, value, callback) {
-        this.beElement.eachNode((el) => {
-            if (typeof nameOrObject === 'string' && value !== undefined) {
-                el[nameOrObject] = value;
-            }
-            else if (typeof nameOrObject === 'object') {
-                Object.entries(nameOrObject).forEach(([name, val]) => {
-                    el[name] = val;
-                });
-            }
-        });
-        return this.beElement;
-    }
-    delete(name, callback) { }
-    getKey(key, callback) {
-        return null;
-    }
-    valueOf() {
-        if (this.beElement.isWhat !== 'element')
-            return null;
-        const el = this.beElement.inputNode;
-        const props = {};
-        for (let prop in el) {
-            if (el.hasOwnProperty(prop)) {
-                props[prop] = el[prop];
-            }
-        }
-        return props;
-    }
-}