@mulsense/xnew 0.6.2 → 0.6.4

package/dist/xnew.d.ts

@@ -20,59 +20,49 @@ declare class MapMap<Key1, Key2, Value> extends Map<Key1, Map<Key2, Value>> {
     delete(key1: Key1, key2: Key2): boolean;
 }
 
-interface TimerOptions {
-    transition?: Function;
-    timeout?: Function;
-    duration: number;
-    iterations: number;
-    easing?: string;
-}
-
 declare class Eventor {
     private map;
     add(element: HTMLElement | SVGElement, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
     remove(type: string, listener: Function): void;
-    private basic;
-    private resize;
-    private change;
-    private input;
-    private click;
-    private click_outside;
-    private pointer;
-    private mouse;
-    private touch;
-    private pointer_outside;
-    private wheel;
-    private drag;
-    private gesture;
-    private key;
-    private key_arrow;
-    private key_wasd;
+    private element_basic;
+    private element_resize;
+    private element_change;
+    private element_input;
+    private element_click;
+    private element_click_outside;
+    private element_pointer;
+    private element_mouse;
+    private element_touch;
+    private element_pointer_outside;
+    private element_wheel;
+    private element_drag;
+    private window_basic;
+    private window_key;
+    private window_key_arrow;
+    private window_key_wasd;
+    private document_basic;
 }
 
 type UnitElement = HTMLElement | SVGElement;
 declare class UnitPromise {
     promise: Promise<any>;
-    component: Function | null;
-    constructor(promise: Promise<any>, component: Function | null);
+    Component: Function | null;
+    constructor(promise: Promise<any>, Component: Function | null);
     then(callback: Function): UnitPromise;
     catch(callback: Function): UnitPromise;
     finally(callback: Function): UnitPromise;
+    private wrap;
 }
 declare class UnitTimer {
     private unit;
     private stack;
-    constructor(options: TimerOptions);
     clear(): void;
-    timeout(timeout: Function, duration?: number): this;
-    iteration(timeout: Function, duration?: number, iterations?: number): this;
-    transition(transition: Function, duration?: number, easing?: string): this;
-    static execute(timer: UnitTimer, options: TimerOptions): void;
-    static next(timer: UnitTimer): void;
-    static Component(unit: Unit, { options, snapshot }: {
-        options: TimerOptions;
-        snapshot: Snapshot;
-    }): void;
+    timeout(callback: Function, duration?: number): UnitTimer;
+    interval(callback: Function, duration?: number, iterations?: number): UnitTimer;
+    transition(transition: Function, duration?: number, easing?: string): UnitTimer;
+    private static execute;
+    private static next;
+    private static Component;
 }
 interface Context {
     stack: Context | null;
@@ -102,7 +92,10 @@ interface Internal {
     ancestors: Unit[];
     children: Unit[];
     promises: UnitPromise[];
-    elements: UnitElement[];
+    nestElements: {
+        element: UnitElement;
+        owned: boolean;
+    }[];
     components: Function[];
     listeners: MapMap<string, Function, {
         element: UnitElement;
@@ -127,9 +120,9 @@ declare class Unit {
     reboot(): void;
     static initialize(unit: Unit, anchor: UnitElement | null): void;
     static finalize(unit: Unit): void;
-    static nest(unit: Unit, tag: string, textContent?: string | number): UnitElement;
+    static nest(unit: Unit, target: UnitElement | string, textContent?: string | number): UnitElement;
     static currentComponent: Function;
-    static extend(unit: Unit, component: Function, props?: Object): {
+    static extend(unit: Unit, Component: Function, props?: Object): {
         [key: string]: any;
     };
     static start(unit: Unit): void;
@@ -143,7 +136,7 @@ declare class Unit {
     static snapshot(unit: Unit): Snapshot;
     static context(unit: Unit, key: any, value?: any): any;
     static component2units: MapSet<Function, Unit>;
-    static find(component: Function): Unit[];
+    static find(Component: Function): Unit[];
     static type2units: MapSet<string, Unit>;
     on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
     off(type?: string, listener?: Function): void;
@@ -154,20 +147,20 @@ declare class Unit {
 
 interface CreateUnit {
     /**
-     * Creates a new Unit component
+     * creates a new Unit component
      * @param Component - component function
      * @param props - properties for component function
-     * @returns A new Unit instance
+     * @returns a new Unit instance
      * @example
      * const unit = xnew(MyComponent, { data: 0 })
      */
     (Component?: Function | string, props?: Object): Unit;
     /**
-     * Creates a new Unit component
+     * creates a new Unit component
      * @param target - HTMLElement | SVGElement, or HTML tag for new element
      * @param Component - component function
      * @param props - properties for component function
-     * @returns A new Unit instance
+     * @returns a new Unit instance
      * @example
      * const unit = xnew(element, MyComponent, { data: 0 })
      * const unit = xnew('<div>', MyComponent, { data: 0 })
@@ -175,15 +168,20 @@ interface CreateUnit {
     (target: HTMLElement | SVGElement | string, Component?: Function | string, props?: Object): Unit;
 }
 
-declare function OpenAndClose(unit: Unit, { open }: {
+interface TransitionOptions {
+    duration?: number;
+    easing?: string;
+}
+declare function OpenAndClose(unit: Unit, { open, transition }: {
     open?: boolean;
+    transition?: TransitionOptions;
 }): {
-    toggle(duration?: number, easing?: string): void;
-    open(duration?: number, easing?: string): void;
-    close(duration?: number, easing?: string): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
 };
 declare function Accordion(unit: Unit): void;
-declare function Modal(unit: Unit): void;
+declare function Popup(unit: Unit): void;
 
 type ScreenFit = 'contain' | 'cover';
 declare function Screen(unit: Unit, { aspect, fit }?: {
@@ -275,12 +273,12 @@ declare namespace xnew {
     type UnitTimer = InstanceType<typeof UnitTimer>;
 }
 declare const xnew: CreateUnit & {
-    nest(tag: string): HTMLElement | SVGElement;
-    extend(component: Function, props?: Object): {
+    nest(target: UnitElement | string): HTMLElement | SVGElement;
+    extend(Component: Function, props?: Object): {
         [key: string]: any;
     };
     context(component: Function): any;
-    promise(promise: Promise<any>): UnitPromise;
+    promise(promise: Promise<any> | Unit): UnitPromise;
     then(callback: Function): UnitPromise;
     catch(callback: Function): UnitPromise;
     finally(callback: Function): UnitPromise;
@@ -288,7 +286,7 @@ declare const xnew: CreateUnit & {
     find(component: Function): Unit[];
     emit(type: string, ...args: any[]): void;
     timeout(timeout: Function, duration?: number): UnitTimer;
-    interval(timeout: Function, duration: number, iterations?: number): UnitTimer;
+    interval(interval: Function, duration: number, iterations?: number): UnitTimer;
     transition(transition: Function, duration?: number, easing?: string): UnitTimer;
     protect(): void;
 } & {
@@ -299,7 +297,7 @@ declare const xnew: CreateUnit & {
         DPad: typeof DPad;
         Panel: typeof Panel;
         Accordion: typeof Accordion;
-        Modal: typeof Modal;
+        Popup: typeof Popup;
     };
     audio: {
         load(path: string): UnitPromise;