@mulsense/xnew 0.1.9 → 0.1.11

package/dist/types/basics/Event.d.ts

@@ -1,3 +1,4 @@
-import { xnew } from '../core/xnew';
-export declare function ResizeEvent(self: any): void;
-export declare function UserEvent(self: xnew.Unit): void;
+import { Unit } from '../core/unit';
+export declare function ResizeEvent(resize: Unit): void;
+export declare function KeyboardEvent(unit: Unit): void;
+export declare function PointerEvent(unit: Unit): void;

package/dist/types/core/time.d.ts

@@ -6,15 +6,19 @@ export declare class Ticker {
 export declare class Timer {
     private timeout;
     private transition;
-    private delay;
+    private duration;
     private loop;
+    private easing;
     private id;
     private time;
     private offset;
     private status;
     private visibilitychange;
     private ticker;
-    constructor(timeout: Function, transition: Function | null, delay: number, loop?: boolean);
+    constructor(transition: Function | null, timeout: Function | null, duration?: number, { loop, easing }?: {
+        loop?: boolean;
+        easing?: string;
+    });
     clear(): void;
     elapsed(): number;
     start(): void;

package/dist/types/core/unit.d.ts

@@ -25,21 +25,19 @@ interface UnitInternal {
     tostart: boolean;
     children: Unit[];
     promises: Promise<any>[];
-    captures: ((unit: Unit) => boolean | void)[];
     elements: UnitElement[];
     components: Function[];
-    listeners1: MapMap<string, Function, [UnitElement, Function]>;
-    listeners2: MapMap<string, Function, [UnitElement | Window | Document, Function]>;
+    listeners1: MapMap<string, Function, {
+        element: UnitElement;
+        execute: Function;
+    }>;
+    listeners2: MapMap<string, Function, {
+        element: UnitElement | Window | Document;
+        execute: Function;
+    }>;
     defines: Record<string, any>;
     systems: Record<string, Function[]>;
 }
-export declare class UnitPromise {
-    private promise;
-    constructor(promise: Promise<any>);
-    then(callback: Function): UnitPromise;
-    catch(callback: Function): UnitPromise;
-    finally(callback: Function): UnitPromise;
-}
 export declare class Unit {
     [key: string]: any;
     _: UnitInternal;
@@ -77,4 +75,41 @@ export declare class Unit {
     static subon(unit: Unit, target: UnitElement | Window | Document, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
     static suboff(unit: Unit, target: UnitElement | Window | Document | null, type?: string, listener?: Function): void;
 }
+export declare class UnitPromise {
+    private promise;
+    constructor(promise: Promise<any>);
+    then(callback: Function): UnitPromise;
+    catch(callback: Function): UnitPromise;
+    finally(callback: Function): UnitPromise;
+}
+export declare class UnitTimer {
+    private unit;
+    private stack;
+    constructor({ transition, timeout, duration, easing, loop }: {
+        transition?: Function;
+        timeout?: Function;
+        duration: number;
+        easing?: string;
+        loop?: boolean;
+    });
+    clear(): void;
+    timeout(timeout: Function, duration?: number): this;
+    transition(transition: Function, duration?: number, easing?: string): this;
+    static execute(timer: UnitTimer, { transition, timeout, duration, easing, loop }: {
+        transition?: Function;
+        timeout?: Function;
+        duration: number;
+        easing?: string;
+        loop?: boolean;
+    }): void;
+    static next(timer: UnitTimer): void;
+    static Component(unit: Unit, { snapshot, transition, timeout, duration, loop, easing }: {
+        snapshot: Snapshot;
+        transition?: Function;
+        timeout?: Function;
+        duration?: number;
+        loop?: boolean;
+        easing?: string;
+    }): void;
+}
 export {};

package/dist/types/core/xnew.d.ts

@@ -121,38 +121,38 @@ export declare const xnew: CreateUnit & {
     find(component: Function): Unit[];
     /**
      * Executes a callback once after a delay, managed by component lifecycle
-     * @param callback - Function to execute after delay
-     * @param delay - Delay in milliseconds
+     * @param timeout - Function to execute after Duration
+     * @param duration - Duration in milliseconds
      * @returns Object with clear() method to cancel the timeout
      * @example
      * const timer = xnew.timeout(() => console.log('Delayed'), 1000)
      * // Cancel if needed: timer.clear()
      */
-    timeout(callback: Function, delay?: number): any;
+    timeout(timeout: Function, duration?: number): any;
     /**
      * Executes a callback repeatedly at specified intervals, managed by component lifecycle
-     * @param callback - Function to execute at each interval
-     * @param delay - Interval duration in milliseconds
+     * @param timeout - Function to execute at each duration
+     * @param duration - Duration in milliseconds
      * @returns Object with clear() method to stop the interval
      * @example
      * const timer = xnew.interval(() => console.log('Tick'), 1000)
      * // Stop when needed: timer.clear()
      */
-    interval(callback: Function, delay: number): any;
+    interval(timeout: Function, duration: number): any;
     /**
      * Creates a transition animation with easing, executing callback with progress values
      * @param callback - Function called with progress value (0.0 to 1.0)
-     * @param interval - Duration of transition in milliseconds
+     * @param duration - Duration of transition in milliseconds
      * @param easing - Easing function: 'linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out' (default: 'linear')
      * @returns Object with clear() and next() methods for controlling transitions
      * @example
-     * xnew.transition(progress => {
-     *   element.style.opacity = progress
-     * }, 500, 'ease-out').next(progress => {
-     *   element.style.transform = `scale(${progress})`
+     * xnew.transition(p => {
+     *   element.style.opacity = p
+     * }, 500, 'ease-out').transition(p => {
+     *   element.style.transform = `scale(${p})`
      * }, 300)
      */
-    transition(callback: Function, interval: number, easing?: string): any;
+    transition(transition: Function, duration?: number, easing?: string): any;
     /**
      * Creates an event listener manager for a target element with automatic cleanup
      * @param target - Element, Window, or Document to attach listeners to
@@ -166,15 +166,5 @@ export declare const xnew: CreateUnit & {
         on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
         off(type?: string, listener?: Function): void;
     };
-    /**
-     * Registers a capture function that can intercept and handle child component events
-     * @param execute - Function that receives child unit and returns boolean (true to stop propagation)
-     * @example
-     * xnew.capture((childUnit) => {
-     *   console.log('Child component created:', childUnit)
-     *   return false // Continue propagation
-     * })
-     */
-    capture(execute: (unit: Unit) => boolean | void): void;
 };
 export {};

package/dist/types/index.d.ts

@@ -1,13 +1,10 @@
 import { xnew as base } from './core/xnew';
 import { Unit } from './core/unit';
-import { ResizeEvent } from './basics/ResizeEvent';
-import { PointerEvent } from './basics/PointerEvent';
-import { KeyboardEvent } from './basics/KeyboardEvent';
+import { AccordionFrame, AccordionHeader, AccordionBullet, AccordionContent } from './basics/Accordion';
+import { ResizeEvent, PointerEvent, KeyboardEvent } from './basics/Event';
 import { Screen } from './basics/Screen';
-import { InputFrame } from './basics/Input';
 import { ModalFrame, ModalContent } from './basics/Modal';
 import { TabFrame, TabButton, TabContent } from './basics/Tab';
-import { AccordionFrame, AccordionHeader, AccordionBullet, AccordionContent } from './basics/Accordion';
 import { DragFrame, DragTarget } from './basics/Drag';
 import { AnalogStick, DirectionalPad } from './basics/Controller';
 import { audio } from './audio/audio';
@@ -25,7 +22,6 @@ declare const basics: {
     TabFrame: typeof TabFrame;
     TabButton: typeof TabButton;
     TabContent: typeof TabContent;
-    InputFrame: typeof InputFrame;
     DragFrame: typeof DragFrame;
     DragTarget: typeof DragTarget;
     AnalogStick: typeof AnalogStick;

package/dist/xnew.d.ts

@@ -51,21 +51,19 @@ interface UnitInternal {
     tostart: boolean;
     children: Unit[];
     promises: Promise<any>[];
-    captures: ((unit: Unit) => boolean | void)[];
     elements: UnitElement[];
     components: Function[];
-    listeners1: MapMap<string, Function, [UnitElement, Function]>;
-    listeners2: MapMap<string, Function, [UnitElement | Window | Document, Function]>;
+    listeners1: MapMap<string, Function, {
+        element: UnitElement;
+        execute: Function;
+    }>;
+    listeners2: MapMap<string, Function, {
+        element: UnitElement | Window | Document;
+        execute: Function;
+    }>;
     defines: Record<string, any>;
     systems: Record<string, Function[]>;
 }
-declare class UnitPromise {
-    private promise;
-    constructor(promise: Promise<any>);
-    then(callback: Function): UnitPromise;
-    catch(callback: Function): UnitPromise;
-    finally(callback: Function): UnitPromise;
-}
 declare class Unit {
     [key: string]: any;
     _: UnitInternal;
@@ -103,6 +101,13 @@ declare class Unit {
     static subon(unit: Unit, target: UnitElement | Window | Document, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
     static suboff(unit: Unit, target: UnitElement | Window | Document | null, type?: string, listener?: Function): void;
 }
+declare class UnitPromise {
+    private promise;
+    constructor(promise: Promise<any>);
+    then(callback: Function): UnitPromise;
+    catch(callback: Function): UnitPromise;
+    finally(callback: Function): UnitPromise;
+}
 
 interface CreateUnit {
     /**
@@ -226,38 +231,38 @@ declare const xnew$1: CreateUnit & {
     find(component: Function): Unit[];
     /**
      * Executes a callback once after a delay, managed by component lifecycle
-     * @param callback - Function to execute after delay
-     * @param delay - Delay in milliseconds
+     * @param timeout - Function to execute after Duration
+     * @param duration - Duration in milliseconds
      * @returns Object with clear() method to cancel the timeout
      * @example
      * const timer = xnew.timeout(() => console.log('Delayed'), 1000)
      * // Cancel if needed: timer.clear()
      */
-    timeout(callback: Function, delay?: number): any;
+    timeout(timeout: Function, duration?: number): any;
     /**
      * Executes a callback repeatedly at specified intervals, managed by component lifecycle
-     * @param callback - Function to execute at each interval
-     * @param delay - Interval duration in milliseconds
+     * @param timeout - Function to execute at each duration
+     * @param duration - Duration in milliseconds
      * @returns Object with clear() method to stop the interval
      * @example
      * const timer = xnew.interval(() => console.log('Tick'), 1000)
      * // Stop when needed: timer.clear()
      */
-    interval(callback: Function, delay: number): any;
+    interval(timeout: Function, duration: number): any;
     /**
      * Creates a transition animation with easing, executing callback with progress values
      * @param callback - Function called with progress value (0.0 to 1.0)
-     * @param interval - Duration of transition in milliseconds
+     * @param duration - Duration of transition in milliseconds
      * @param easing - Easing function: 'linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out' (default: 'linear')
      * @returns Object with clear() and next() methods for controlling transitions
      * @example
-     * xnew.transition(progress => {
-     *   element.style.opacity = progress
-     * }, 500, 'ease-out').next(progress => {
-     *   element.style.transform = `scale(${progress})`
+     * xnew.transition(p => {
+     *   element.style.opacity = p
+     * }, 500, 'ease-out').transition(p => {
+     *   element.style.transform = `scale(${p})`
      * }, 300)
      */
-    transition(callback: Function, interval: number, easing?: string): any;
+    transition(transition: Function, duration?: number, easing?: string): any;
     /**
      * Creates an event listener manager for a target element with automatic cleanup
      * @param target - Element, Window, or Document to attach listeners to
@@ -271,23 +276,31 @@ declare const xnew$1: CreateUnit & {
         on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
         off(type?: string, listener?: Function): void;
     };
-    /**
-     * Registers a capture function that can intercept and handle child component events
-     * @param execute - Function that receives child unit and returns boolean (true to stop propagation)
-     * @example
-     * xnew.capture((childUnit) => {
-     *   console.log('Child component created:', childUnit)
-     *   return false // Continue propagation
-     * })
-     */
-    capture(execute: (unit: Unit) => boolean | void): void;
 };
 
-declare function ResizeEvent(resize: Unit): void;
-
-declare function PointerEvent(unit: Unit): void;
+declare function AccordionFrame(frame: Unit, { open, duration, easing }?: {
+    open?: boolean;
+    duration?: number;
+    easing?: string;
+}): {
+    toggle(): void;
+    open(): void;
+    close(): void;
+};
+declare function AccordionHeader(header: Unit, {}?: {}): void;
+declare function AccordionBullet(bullet: Unit, { type }?: {
+    type?: string;
+}): void;
+declare function AccordionContent(content: Unit, {}?: {}): {
+    transition({ element, rate }: {
+        element: HTMLElement;
+        rate: number;
+    }): void;
+};
 
+declare function ResizeEvent(resize: Unit): void;
 declare function KeyboardEvent(unit: Unit): void;
+declare function PointerEvent(unit: Unit): void;
 
 declare function Screen(screen: Unit, { width, height, fit }?: {
     width?: number | undefined;
@@ -298,8 +311,6 @@ declare function Screen(screen: Unit, { width, height, fit }?: {
     resize(width: number, height: number): void;
 };
 
-declare function InputFrame(frame: Unit, {}?: {}): void;
-
 declare function ModalFrame(frame: Unit, { duration, easing }?: {
     duration?: number;
     easing?: string;
@@ -339,26 +350,6 @@ declare function TabContent(content: Unit, { key }?: {
     }): void;
 };
 
-declare function AccordionFrame(frame: Unit, { open, duration, easing }?: {
-    open?: boolean;
-    duration?: number;
-    easing?: string;
-}): {
-    toggle(): void;
-    open(): void;
-    close(): void;
-};
-declare function AccordionHeader(header: Unit, {}?: {}): void;
-declare function AccordionBullet(bullet: Unit, { type }?: {
-    type?: string;
-}): void;
-declare function AccordionContent(content: Unit, {}?: {}): {
-    transition({ element, rate }: {
-        element: HTMLElement;
-        rate: number;
-    }): void;
-};
-
 declare function DragFrame(frame: Unit, { x, y }?: {
     x?: number;
     y?: number;
@@ -455,7 +446,6 @@ declare const basics: {
     TabFrame: typeof TabFrame;
     TabButton: typeof TabButton;
     TabContent: typeof TabContent;
-    InputFrame: typeof InputFrame;
     DragFrame: typeof DragFrame;
     DragTarget: typeof DragTarget;
     AnalogStick: typeof AnalogStick;