@leafer-in/state 1.8.0 → 1.9.1

package/dist/state.cjs

@@ -1,20 +1,18 @@
-'use strict';
+"use strict";
 
-var core = require('@leafer-ui/core');
+var core = require("@leafer-ui/core");
 
 function stateType(defaultValue, styleName) {
-    return core.decorateLeafAttr(defaultValue, (key) => core.attr({
+    return core.decorateLeafAttr(defaultValue, key => core.attr({
         set(value) {
             this.__setAttr(key, value);
-            if (this.leaferIsReady)
-                styleName ? core.State.setStyleName(this, styleName, value) : core.State.set(this, value);
-            else
-                this.__layout.stateStyleChanged = true;
+            if (this.leaferIsReady) styleName ? core.State.setStyleName(this, styleName, value) : core.State.set(this, value); else this.__layout.stateStyleChanged = true;
         }
     }));
 }
+
 function stateStyleType(defaultValue) {
-    return core.decorateLeafAttr(defaultValue, (key) => core.attr({
+    return core.decorateLeafAttr(defaultValue, key => core.attr({
         set(value) {
             this.__setAttr(key, value);
             this.__layout.stateStyleChanged = true;
@@ -23,14 +21,12 @@ function stateStyleType(defaultValue) {
 }
 
 function findParentButton(leaf, button) {
-    if (button && button !== true)
-        return button;
+    if (button && button !== true) return button;
     if (!leaf.button) {
-        let { parent } = leaf;
+        let {parent: parent} = leaf;
         for (let i = 0; i < 2; i++) {
             if (parent) {
-                if (parent.button)
-                    return parent;
+                if (parent.button) return parent;
                 parent = parent.parent;
             }
         }
@@ -39,121 +35,106 @@ function findParentButton(leaf, button) {
 }
 
 function setStyle(leaf, style) {
-    if (typeof style !== 'object')
-        style = undefined;
-    updateStyle(leaf, style, 'in');
+    if (!core.isObject(style)) style = undefined;
+    updateStyle(leaf, style, "in");
 }
+
 function unsetStyle(leaf, style) {
-    const { normalStyle } = leaf;
-    if (typeof style !== 'object')
-        style = undefined;
+    const {normalStyle: normalStyle} = leaf;
+    if (!core.isObject(style)) style = undefined;
     if (normalStyle) {
-        if (!style)
-            style = normalStyle;
-        updateStyle(leaf, style, 'out');
+        if (!style) style = normalStyle;
+        updateStyle(leaf, style, "out");
     }
 }
+
 const emprtyStyle = {};
+
 function updateStyle(leaf, style, type) {
-    const { normalStyle } = leaf;
-    if (!style)
-        style = emprtyStyle;
+    const {normalStyle: normalStyle} = leaf;
+    if (!style) style = emprtyStyle;
     if (style.scale) {
         core.MathHelper.assignScale(style, style.scale);
         delete style.scale;
     }
-    if (style === emprtyStyle || !core.State.canAnimate)
-        type = null;
+    if (style === emprtyStyle || !core.State.canAnimate) type = null;
     let transition = type ? getTransition(type, style, leaf) : false;
     const fromStyle = transition ? getFromStyle(leaf, style) : undefined;
     const nextStyle = core.State.canAnimate && getStyle(leaf);
-    if (nextStyle)
-        leaf.killAnimate('transition');
-    if (normalStyle)
-        leaf.set(normalStyle, 'temp');
+    if (nextStyle) leaf.killAnimate("transition");
+    if (normalStyle) leaf.set(normalStyle, "temp");
     const statesStyle = getStyle(leaf);
     if (statesStyle) {
-        const { animation } = statesStyle;
+        const {animation: animation} = statesStyle;
         if (animation) {
-            const animate = leaf.animate(animation, undefined, 'animation', true);
+            const animate = leaf.animate(animation, undefined, "animation", true);
             Object.assign(statesStyle, animate.endingStyle);
-            if (type !== 'in' || style.animation !== animation)
-                animate.kill();
-            else
-                transition = false;
+            if (type !== "in" || style.animation !== animation) animate.kill(); else transition = false;
             delete statesStyle.animation;
         }
         leaf.normalStyle = filterStyle(statesStyle, leaf);
-        leaf.set(statesStyle, 'temp');
-    }
-    else {
+        leaf.set(statesStyle, "temp");
+    } else {
         leaf.normalStyle = undefined;
     }
     if (transition) {
         const toStyle = filterStyle(fromStyle, leaf);
-        leaf.set(fromStyle, 'temp');
-        leaf.animate([fromStyle, toStyle], transition, 'transition', true);
+        leaf.set(fromStyle, "temp");
+        leaf.animate([ fromStyle, toStyle ], transition, "transition", true);
     }
     leaf.__layout.stateStyleChanged = false;
 }
+
 function getStyle(leaf) {
     let exist;
     const style = {}, button = findParentButton(leaf);
-    const state = button ? (leaf.state || button.state) : leaf.state;
+    const state = button ? leaf.state || button.state : leaf.state;
     const stateStyle = state && leaf.states[state];
-    if (stateStyle && core.State.isState(state, leaf, button))
-        exist = assign(style, stateStyle);
+    if (stateStyle && core.State.isState(state, leaf, button)) exist = assign(style, stateStyle);
     const selectedStyle = style.selectedStyle || leaf.selectedStyle;
-    if (selectedStyle && core.State.isSelected(leaf, button))
-        exist = assign(style, selectedStyle);
+    if (selectedStyle && core.State.isSelected(leaf, button)) exist = assign(style, selectedStyle);
     const placeholderStyle = style.placeholderStyle || leaf.placeholderStyle;
-    if (placeholderStyle && core.State.isPlacehold(leaf, button))
-        exist = assign(style, placeholderStyle);
+    if (placeholderStyle && core.State.isPlacehold(leaf, button)) exist = assign(style, placeholderStyle);
     if (core.State.isDisabled(leaf, button)) {
         const disabledStyle = style.disabledStyle || leaf.disabledStyle;
-        if (disabledStyle)
-            exist = assign(style, disabledStyle);
-    }
-    else {
+        if (disabledStyle) exist = assign(style, disabledStyle);
+    } else {
         const focusStyle = style.focusStyle || leaf.focusStyle;
-        if (focusStyle && core.State.isFocus(leaf, button))
-            exist = assign(style, focusStyle);
+        if (focusStyle && core.State.isFocus(leaf, button)) exist = assign(style, focusStyle);
         const hoverStyle = style.hoverStyle || leaf.hoverStyle;
-        if (hoverStyle && core.State.isHover(leaf, button))
-            exist = assign(style, hoverStyle);
+        if (hoverStyle && core.State.isHover(leaf, button)) exist = assign(style, hoverStyle);
         const pressStyle = style.pressStyle || leaf.pressStyle;
-        if (pressStyle && core.State.isPress(leaf, button))
-            exist = assign(style, pressStyle);
+        if (pressStyle && core.State.isPress(leaf, button)) exist = assign(style, pressStyle);
     }
     return exist ? style : undefined;
 }
+
 function filterStyle(style, data, addStyle, useAnimateExcludes) {
     const to = addStyle ? style : {}, forStyle = addStyle || style;
     for (let key in forStyle) {
         if (useAnimateExcludes) {
-            if (!core.State.animateExcludes[key])
-                to[key] = data[key];
-        }
-        else
-            to[key] = data[key];
+            if (!core.State.animateExcludes[key]) to[key] = data[key];
+        } else to[key] = data[key];
     }
     return to;
 }
+
 function filterAnimateStyle(style, data, addStyle) {
     return filterStyle(style, data, addStyle, true);
 }
+
 function getFromStyle(leaf, style) {
     const fromStyle = filterAnimateStyle(style, leaf), animate = leaf.animate();
-    if (animate)
-        filterAnimateStyle(fromStyle, leaf, animate.fromStyle);
+    if (animate) filterAnimateStyle(fromStyle, leaf, animate.fromStyle);
     return fromStyle;
 }
+
 function getTransition(type, style, data) {
-    let name = type === 'in' ? 'transition' : 'transitionOut';
-    if (type === 'out' && core.isNull(data[name]) && core.isNull(style[name]))
-        name = 'transition';
+    let name = type === "in" ? "transition" : "transitionOut";
+    if (type === "out" && core.isNull(data[name]) && core.isNull(style[name])) name = "transition";
     return core.isNull(style[name]) ? data[name] : style[name];
 }
+
 function assign(style, stateStyle) {
     Object.assign(style, stateStyle);
     return true;
@@ -161,90 +142,79 @@ function assign(style, stateStyle) {
 
 function setPointerState(leaf, stateName) {
     const style = leaf[stateName];
-    if (style)
-        setStyle(leaf, style);
-    if (leaf.button)
-        setChildrenState(leaf.children, stateName);
+    if (style) setStyle(leaf, style);
+    if (leaf.button) setChildrenState(leaf.children, stateName);
 }
+
 function setState(leaf, stateName, stateStyle) {
-    if (!stateStyle)
-        stateStyle = leaf.states[stateName];
+    if (!stateStyle) stateStyle = leaf.states[stateName];
     setStyle(leaf, stateStyle);
-    if (leaf.button)
-        setChildrenState(leaf.children, null, stateName);
+    if (leaf.button) setChildrenState(leaf.children, null, stateName);
 }
+
 function setChildrenState(children, stateType, stateName) {
-    if (!children)
-        return;
+    if (!children) return;
     let leaf, update;
     for (let i = 0, len = children.length; i < len; i++) {
         leaf = children[i];
         if (stateType) {
             update = true;
             switch (stateType) {
-                case 'hoverStyle':
-                    if (core.State.isHover(leaf))
-                        update = false;
-                    break;
-                case 'pressStyle':
-                    if (core.State.isPress(leaf))
-                        update = false;
-                    break;
-                case 'focusStyle':
-                    if (core.State.isFocus(leaf))
-                        update = false;
+              case "hoverStyle":
+                if (core.State.isHover(leaf)) update = false;
+                break;
+
+              case "pressStyle":
+                if (core.State.isPress(leaf)) update = false;
+                break;
+
+              case "focusStyle":
+                if (core.State.isFocus(leaf)) update = false;
             }
-            if (update)
-                setPointerState(leaf, stateType);
-        }
-        else if (stateName !== undefined)
-            setState(leaf, stateName);
-        if (leaf.isBranch)
-            setChildrenState(leaf.children, stateType, stateName);
+            if (update) setPointerState(leaf, stateType);
+        } else if (!core.isUndefined(stateName)) setState(leaf, stateName);
+        if (leaf.isBranch) setChildrenState(leaf.children, stateType, stateName);
     }
 }
 
 function unsetPointerState(leaf, stateName) {
     const style = leaf[stateName];
-    if (style)
-        unsetStyle(leaf, style);
-    if (leaf.button)
-        unsetChildrenState(leaf.children, stateName);
+    if (style) unsetStyle(leaf, style);
+    if (leaf.button) unsetChildrenState(leaf.children, stateName);
 }
+
 function unsetState(leaf, stateName, stateStyle) {
     unsetStyle(leaf, stateStyle);
-    if (leaf.button)
-        unsetChildrenState(leaf.children, null, stateName);
+    if (leaf.button) unsetChildrenState(leaf.children, null, stateName);
 }
+
 function unsetChildrenState(children, stateType, stateName) {
-    if (!children)
-        return;
+    if (!children) return;
     let leaf;
     for (let i = 0, len = children.length; i < len; i++) {
         leaf = children[i];
-        if (stateType)
-            unsetPointerState(leaf, stateType);
-        else if (stateName !== undefined)
-            unsetState(leaf, stateName);
-        if (leaf.isBranch)
-            unsetChildrenState(leaf.children, stateType, stateName);
+        if (stateType) unsetPointerState(leaf, stateType); else if (!core.isUndefined(stateName)) unsetState(leaf, stateName);
+        if (leaf.isBranch) unsetChildrenState(leaf.children, stateType, stateName);
     }
 }
 
 function updateEventStyle(leaf, eventType) {
     switch (eventType) {
-        case core.PointerEvent.ENTER:
-            setPointerState(leaf, 'hoverStyle');
-            break;
-        case core.PointerEvent.LEAVE:
-            unsetPointerState(leaf, 'hoverStyle');
-            break;
-        case core.PointerEvent.DOWN:
-            setPointerState(leaf, 'pressStyle');
-            break;
-        case core.PointerEvent.UP:
-            unsetPointerState(leaf, 'pressStyle');
-            break;
+      case core.PointerEvent.ENTER:
+        setPointerState(leaf, "hoverStyle");
+        break;
+
+      case core.PointerEvent.LEAVE:
+        unsetPointerState(leaf, "hoverStyle");
+        break;
+
+      case core.PointerEvent.DOWN:
+        setPointerState(leaf, "pressStyle");
+        break;
+
+      case core.PointerEvent.UP:
+        unsetPointerState(leaf, "pressStyle");
+        break;
     }
 }
 
@@ -255,32 +225,32 @@ function checkPointerState(fnName, leaf, button) {
         find = interaction[fnName](leaf);
         if (!find && button) {
             const parentButton = findParentButton(leaf, button);
-            if (parentButton)
-                find = interaction[fnName](parentButton);
+            if (parentButton) find = interaction[fnName](parentButton);
         }
     }
     return find;
 }
+
 function checkFixedState(attrName, leaf, button) {
     let find = leaf[attrName];
     if (!find && button) {
         const parentButton = findParentButton(leaf, button);
-        if (parentButton)
-            find = parentButton[attrName];
+        if (parentButton) find = parentButton[attrName];
     }
     return find;
 }
+
 function checkState(stateName, leaf, button) {
     let find = leaf.states[stateName];
     if (!find && button) {
         const parentButton = findParentButton(leaf, button);
-        if (parentButton)
-            find = parentButton.states[stateName];
+        if (parentButton) find = parentButton.states[stateName];
     }
     return !!find;
 }
 
-core.Plugin.add('state');
+core.Plugin.add("state");
+
 core.State.animateExcludes = {
     animation: 1,
     animationOut: 1,
@@ -297,58 +267,108 @@ core.State.animateExcludes = {
     disabledStyle: 1,
     placeholderStyle: 1
 };
-core.State.isState = function (state, leaf, button) { return checkState(state, leaf, button); };
-core.State.isSelected = function (leaf, button) { return checkFixedState('selected', leaf, button); };
-core.State.isDisabled = function (leaf, button) { return checkFixedState('disabled', leaf, button); };
-core.State.isFocus = function (leaf, button) { return checkPointerState('isFocus', leaf, button); };
-core.State.isHover = function (leaf, button) { return checkPointerState('isHover', leaf, button); };
-core.State.isPress = function (leaf, button) { return checkPointerState('isPress', leaf, button); };
-core.State.isPlacehold = function (leaf, _button) { return leaf.__.__isPlacehold; };
-core.State.isDrag = function (leaf, button) { return checkPointerState('isDrag', leaf, button); };
-core.State.setStyleName = function (leaf, stateType, value) { value ? setState(leaf, stateType, leaf[stateType]) : unsetState(leaf, stateType, leaf[stateType]); };
-core.State.set = function (leaf, stateName) { const style = leaf.states[stateName]; style ? setState(leaf, stateName, style) : unsetState(leaf, stateName, style); };
+
+core.State.isState = function(state, leaf, button) {
+    return checkState(state, leaf, button);
+};
+
+core.State.isSelected = function(leaf, button) {
+    return checkFixedState("selected", leaf, button);
+};
+
+core.State.isDisabled = function(leaf, button) {
+    return checkFixedState("disabled", leaf, button);
+};
+
+core.State.isFocus = function(leaf, button) {
+    return checkPointerState("isFocus", leaf, button);
+};
+
+core.State.isHover = function(leaf, button) {
+    return checkPointerState("isHover", leaf, button);
+};
+
+core.State.isPress = function(leaf, button) {
+    return checkPointerState("isPress", leaf, button);
+};
+
+core.State.isPlacehold = function(leaf, _button) {
+    return leaf.__.__isPlacehold;
+};
+
+core.State.isDrag = function(leaf, button) {
+    return checkPointerState("isDrag", leaf, button);
+};
+
+core.State.setStyleName = function(leaf, stateType, value) {
+    value ? setState(leaf, stateType, leaf[stateType]) : unsetState(leaf, stateType, leaf[stateType]);
+};
+
+core.State.set = function(leaf, stateName) {
+    const style = leaf.states[stateName];
+    style ? setState(leaf, stateName, style) : unsetState(leaf, stateName, style);
+};
+
 core.State.getStyle = getStyle;
+
 core.State.updateStyle = updateStyle;
+
 core.State.updateEventStyle = updateEventStyle;
+
 const ui = core.UI.prototype;
-core.UI.addAttr('selected', false, stateType, 'selectedStyle');
-core.UI.addAttr('disabled', false, stateType, 'disabledStyle');
-core.UI.addAttr('states', {}, stateStyleType);
-core.UI.addAttr('state', '', stateType);
-core.UI.addAttr('normalStyle', undefined, core.dataType);
-core.UI.addAttr('hoverStyle', undefined, stateStyleType);
-core.UI.addAttr('pressStyle', undefined, stateStyleType);
-core.UI.addAttr('focusStyle', undefined, stateStyleType);
-core.UI.addAttr('selectedStyle', undefined, stateStyleType);
-core.UI.addAttr('disabledStyle', undefined, stateStyleType);
-core.UI.addAttr('placeholderStyle', undefined, stateStyleType);
-core.UI.addAttr('button', false, core.dataType);
-ui.focus = function (value = true) {
+
+core.UI.addAttr("selected", false, stateType, "selectedStyle");
+
+core.UI.addAttr("disabled", false, stateType, "disabledStyle");
+
+core.UI.addAttr("states", {}, stateStyleType);
+
+core.UI.addAttr("state", "", stateType);
+
+core.UI.addAttr("normalStyle", undefined, core.dataType);
+
+core.UI.addAttr("hoverStyle", undefined, stateStyleType);
+
+core.UI.addAttr("pressStyle", undefined, stateStyleType);
+
+core.UI.addAttr("focusStyle", undefined, stateStyleType);
+
+core.UI.addAttr("selectedStyle", undefined, stateStyleType);
+
+core.UI.addAttr("disabledStyle", undefined, stateStyleType);
+
+core.UI.addAttr("placeholderStyle", undefined, stateStyleType);
+
+core.UI.addAttr("button", false, core.dataType);
+
+ui.focus = function(value = true) {
     this.waitLeafer(() => {
-        let { focusData } = this.app.interaction;
+        let {focusData: focusData} = this.app.interaction;
         if (value) {
-            if (focusData)
-                focusData.focus(false);
+            if (focusData) focusData.focus(false);
             focusData = this;
-        }
-        else
-            focusData = null;
+        } else focusData = null;
         this.app.interaction.focusData = focusData;
-        value ? setPointerState(this, 'focusStyle') : unsetPointerState(this, 'focusStyle');
+        value ? setPointerState(this, "focusStyle") : unsetPointerState(this, "focusStyle");
     });
 };
-ui.updateState = function () {
-    core.State.updateStyle(this, undefined, 'in');
+
+ui.updateState = function() {
+    core.State.updateStyle(this, undefined, "in");
 };
-const text = core.Text.prototype, textKey = 'text';
-core.defineKey(text, textKey, Object.assign(Object.assign({}, core.getDescriptor(text, textKey)), { set(value) {
+
+const text = core.Text.prototype, textKey = "text";
+
+core.defineKey(text, textKey, Object.assign(Object.assign({}, core.getDescriptor(text, textKey)), {
+    set(value) {
         const t = this, oldValue = t.text;
         if (t.__setAttr(textKey, value)) {
             core.doBoundsType(t);
-            if (t.placeholderStyle && t.placeholder && (oldValue === '' || value === ''))
-                t.__layout.stateStyleChanged = true;
+            if (t.placeholderStyle && t.placeholder && (oldValue === "" || value === "")) t.__layout.stateStyleChanged = true;
         }
-    } }));
+    }
+}));
 
 exports.stateStyleType = stateStyleType;
+
 exports.stateType = stateType;