@shijiu/jsview 1.9.731 → 1.9.759

package/dom/jsview-dom/src/dom-wrapper/style/KeyframeRule.js

@@ -1,11 +0,0 @@
-export default class KeyframeRule {
-    constructor(text) {
-        let nameStartIdx = text.indexOf(KeyframeRule.KeyFramesFlag) + KeyframeRule.KeyFramesFlag.length;
-        let nameEndIdx = text.indexOf("{");
-        let name = text.substring(nameStartIdx, nameEndIdx);
-        this.name = name.trim();
-        this.cssText = text;
-    }
-}
-
-KeyframeRule.KeyFramesFlag = "@keyframes"

package/dom/jsview-dom/src/dom-wrapper/style/StyleDeclaration.js

@@ -1,609 +0,0 @@
-/* eslint-disable no-extra-boolean-cast */
-/* eslint-disable no-prototype-builtins */
-import {JsvLazySyncCache} from "../utils/JsvLazySyncCache"
-import StyleValue from "./StyleValue"
-import Inset from "./Inset"
-import BorderImage from "./BorderImage"
-import JsvStyleVariable from "./JsvStyleVariable"
-import Forge from "../../engine-js/ForgeDefine"
-import Log from "../utils/Log"
-
-class StyleDeclaration {
-    constructor() {
-        this.jsvStore = {};
-        this.jsvLazySyncCache = new JsvLazySyncCache("style");
-        this.jsvLockedProps = {};
-        this.jsvNamedClassArray = null;
-        this.jsvCustomStyles = {};
-
-        this.jsvLazyPrevClassNames = null;
-        this.jsvLazyPrevInheritedClassNames = null;
-        this.jsvLazyClassNames = null;
-        this.jsvLazyInheritedClassNames = null;
-        this.jsvLazyClassAttributes = null;
-    }
-
-    setProperty(propName, propValue) {
-        // console.log("StyleDeclaration.setPropertyValue() propName=" + propName + ", propValue=" + propValue);
-
-        if (typeof document.jsvCheckStyleFormat === "function") {
-            document.jsvCheckStyleFormat(propName, propValue);
-        }
-
-        this.jsvLockedProps[propName] = true; // 通过Style设置过的prop不被class style影响
-
-        propValue = StyleDeclaration.JsvConvertPropValue(propName, propValue); // 属性规范化
-        this.jsvUpdateProperty(propName, propValue);
-    }
-
-    getPropertyValue(propName) {
-        if(this.jsvStore[propName] !== undefined) {
-            return this.jsvStore[propName];
-        }
-
-        // 去class中查找, 固定值的class属性没有在jsvStore中。
-        let propValue = this.jsvGetClassPropValue(this.jsvLazyClassNames, this.jsvLazyClassAttributes, propName)
-        if (propValue) {
-            // Animation和Transition设计到了Forge的处理，所以未在编译期格式化
-            if (propName == StyleDeclaration.PROP.ANIMATION) {
-                propValue = StyleValue.ConvertAnimation(propValue);
-            } else if (propName == StyleDeclaration.PROP.TRANSITION) {
-                propValue = StyleValue.ConvertTransition(propValue);
-            }
-
-            // BackgroundImage的linear-gradient设计到了Forge的处理，所以未在编译期格式化
-            if (propName == StyleDeclaration.PROP.BACKGROUNDIMAGE) {
-                propValue = StyleValue.ConvertGradient(propValue);
-            }
-        // console.log("StyleDeclaration.getPropertyValue(0) propName=" + propName + ", propValue=" + propValue);
-            return propValue;
-        }
-        propValue = this.jsvGetClassPropValue(this.jsvLazyInheritedClassNames, this.jsvLazyClassAttributes, propName)
-        if (propValue) {
-            // Animation和Transition设计到了Forge的处理，所以未在编译期格式化
-            if (propName == StyleDeclaration.PROP.ANIMATION) {
-                propValue = StyleValue.ConvertAnimation(propValue);
-            } else if (propName == StyleDeclaration.PROP.TRANSITION) {
-                propValue = StyleValue.ConvertTransition(propValue);
-            }
-
-            // BackgroundImage的linear-gradient设计到了Forge的处理，所以未在编译期格式化
-            if (propName == StyleDeclaration.PROP.BACKGROUNDIMAGE) {
-                propValue = StyleValue.ConvertGradient(propValue);
-            }
-        // console.log("StyleDeclaration.getPropertyValue(1) propName=" + propName + ", propValue=" + propValue);
-            return propValue;
-        }
-
-        // console.log("StyleDeclaration.getPropertyValue() propName=" + propName + ", propValue=" + propValue);
-        return undefined;
-    }
-
-    jsvDestory() {
-        // console.warn("StyleDeclaration.jsvDestory()");
-        JsvStyleVariable.RemoveRefStyle(this);
-    }
-
-    jsvUpdateProperty(propName, propValue) {
-        let type = this.jsvSetPropertySilently(propName, propValue);
-        if(!!type) {
-            this.jsvLazySyncCache.setCacheProperty(type, true);
-        }
-    }
-
-    jsvSetPropertySilently(propName, propValue) {
-        if(propName.startsWith('--')) {
-            JsvStyleVariable.UpdateValue(propName, propValue);
-            return;
-        } else if(typeof(propValue) === 'string' && propValue.startsWith('var(--')) {
-            JsvStyleVariable.AppendRefStyle(propValue, this, propName);
-            return;
-        }
-        
-        if (propName === "animation") {
-          if (this.jsvStore[propName]?.originStr === propValue?.originStr) {
-            return null;
-          }
-        } else if (this.jsvStore[propName] === propValue) { // no changed
-            return null;
-        }
-        this.jsvStore[propName] = propValue;
-        let type = StyleDeclaration.JsvGetStyleType(propName);
-
-        return type
-    }
-
-    jsvApplyClasses(classNames, isInherited) {
-        if (!classNames) {
-            // 当className="undefined" 的用法，在reactive语法中经常遇到这种情况
-            // TODO: 未考虑className本身是reactive场景，vue/react现行app框架未出现这种场景
-            return;
-        }
-
-         // JsvStyle_标识的class是react的旧处理方式，如果没有此标识，用新的css-to-js方式处理
-        if(classNames.indexOf("JsvStyle_") < 0) {
-            if (!isInherited) {
-                this.jsvLazyPrevClassNames = this.jsvLazyClassNames;
-                this.jsvLazyClassNames = classNames.split(" ");
-            } else {
-                this.jsvLazyPrevInheritedClassNames = this.jsvLazyInheritedClassNames;
-                this.jsvLazyInheritedClassNames = classNames.split(" ");
-            }
-
-            const type = StyleDeclaration.TYPE.CLASS_NAME;
-            this.jsvLazySyncCache.setCacheProperty(type, true);
-
-            return;
-        }
-
-        // 带JsvStyle_标识的class处理方式
-        if (classNames) {
-            let class_array = classNames.split(" ");
-            let target = {};
-
-            this.jsvNamedClassArray = new Array(class_array.length);
-            let push_idx = 0;
-
-            // 以此合并所有class设定
-            for (let item of class_array) {
-                let class_obj = null;
-                if (Forge.ReactUtils.StyleClassMap.hasOwnProperty(item)) {
-                    // 属性转化
-                    class_obj = Forge.ReactUtils.StyleClassMap[item];
-                    let attach = class_obj.getAttach();
-                    if (attach == null) {
-                        // 首次使用，进行属性转化
-                        let styles = class_obj.getStyles();
-                        attach = {
-                            altStyles:{}, // 转化后的style
-                            hasTextMajorStyle: 0, // 0: 未检测, 1: 普通JsvStyleClass, 2:JsvTextStyleClass或者含有文字属性的JsvStyleClass
-                            textPackAttr: null,
-                        };
-                        for (let prop_name in styles) {
-                            attach.altStyles[prop_name] = StyleDeclaration.JsvConvertPropValue(prop_name, styles[prop_name]);
-                        }
-                        class_obj.updateAttach(attach);
-                    }
-
-                    // 文字class附加处理
-                    // 读取文字相关的custom style属性
-                    if (class_obj.classType() === "text") {
-                        attach.hasTextMajorStyle = 2;
-
-                        // 读出text只有属性
-                        if (attach.textPackAttr === null) {
-                            attach.textPackAttr = {
-                                textLineAlign: class_obj.getLineAlign(),
-                                textVerticalAlign: class_obj.getVerticalAlign(),
-                            };
-                        }
-
-                        // 更新text custom style
-                        this.jsvCustomStyles.textLineAlign = attach.textPackAttr.textLineAlign;
-                        this.jsvCustomStyles.textVerticalAlign = attach.textPackAttr.textVerticalAlign;
-                    }
-
-                    // 项目合并
-                    Object.assign(target, attach.altStyles);
-                } else {
-                    console.error("Error: className not found");
-                }
-
-                // 关联className对应的class，为后续使用
-                this.jsvNamedClassArray[push_idx] = class_obj;
-                push_idx++;
-            }
-
-            for (let prop_name in target) {
-                // 将未锁定的属性以此设定进style中，并触发刷新
-                if (!this.jsvLockedProps[prop_name]) {
-                    this.jsvUpdateProperty(prop_name, target[prop_name]);
-                }
-            }
-        }
-    }
-
-    jsvAppendClassAttribute(attribute) {
-        if(!this.jsvLazyClassAttributes) {
-            this.jsvLazyClassAttributes = new Set();
-        }
-        this.jsvLazyClassAttributes.add(attribute);
-
-        const type = StyleDeclaration.TYPE.CLASS_NAME;
-        this.jsvLazySyncCache.setCacheProperty(type, true);
-    }
-
-    jsvSetClassProperty(propName) {
-        let type = StyleDeclaration.JsvGetStyleType(propName);
-        if(!!type) {
-            this.jsvLazySyncCache.setCacheProperty(type, true);
-        }
-    }
-
-    jsvGetClassPropValue(classNames, classAttributes, propName) {
-        if(!classNames) {
-            return undefined;
-        }
-
-        const searchPropValue = (styleSheets, classNames, classAttribute, propName) => {
-            for (let idx = classNames.length - 1; idx >= 0; idx--) {
-                let className = classNames[idx];
-                if(!!classAttribute) { // 添加属性选择器
-                    className += ("[" + classAttribute + "]");
-                }
-                if (!styleSheets.hasOwnProperty(className)) {
-                    continue;
-                }
-    
-                const declarations = styleSheets[className];
-                if(!declarations.hasOwnProperty(propName)) {
-                    continue;
-                }
-
-                let propValue = declarations[propName];
-                if(typeof(propValue) === 'string' && propValue.startsWith('var(--')) {
-                    propValue = JsvStyleVariable.GetValue(propValue);
-                }
-
-                return propValue;
-            }
-        };
-
-        const styleSheets = window.JsvCode.Dom.StyleSheets;
-
-        // vue3通过属性选择器来实现scoped
-        for (const classAttribute of (classAttributes ?? [])) {
-            const propValue = searchPropValue(styleSheets, classNames, classAttribute, propName);
-            if(!!propValue) {
-                return propValue;
-            }
-        }
-
-        // 查找普通class
-        const propValue = searchPropValue(styleSheets, classNames, null, propName);
-
-        return propValue;
-    }
-
-    jsvGetClassDeclarations(classNames, classAttributes) {
-        if(!classNames) {
-            return undefined;
-        }
-
-        const getClassDeclarations = (styleSheets, classNames, classAttribute) => {
-            let classDeclarations = {}
-            for (let idx = 0; idx < classNames.length; idx++) {
-                let className = classNames[idx];
-                if(!!classAttribute) { // 添加属性选择器
-                    className += ("[" + classAttribute + "]");
-                }
-                if (!styleSheets.hasOwnProperty(className)) {
-                    continue;
-                }
-    
-                const declarations = styleSheets[className];
-                Object.assign(classDeclarations, declarations);
-            }
-
-            return classDeclarations;
-        };
-
-        const styleSheets = window.JsvCode.Dom.StyleSheets;
-
-        // 获取普通class
-        let classDeclarations = getClassDeclarations(styleSheets, classNames, null);
-
-        // vue3通过属性选择器来实现scoped
-        for (const classAttribute of (classAttributes ?? [])) {
-            const declarations = getClassDeclarations(styleSheets, classNames, classAttribute);
-            Object.assign(classDeclarations, declarations);
-        }
-
-        return classDeclarations;
-    }
-
-    jsvUpdateChangedClasses(lazyClassNames, lazyPrevClassNames, lazyClassAttributes) {
-        Log.D("jsvGetChangedClassTypes() classNames=" + lazyClassNames);
-
-        let changedTypes = {}
-
-        // 重置上一次的class
-        if(!!lazyPrevClassNames) {
-            JsvStyleVariable.RemoveRefStyle(this);
-
-            const prevClassDeclarations = this.jsvGetClassDeclarations(lazyPrevClassNames, lazyClassAttributes);
-            for(const propName of Object.keys(prevClassDeclarations)) {
-                const type = StyleDeclaration.JsvGetStyleType(propName);
-                changedTypes[type] = true;
-            }
-            lazyPrevClassNames = null;
-        }
-
-        // 设置本次的class
-        if(!!lazyClassNames) {
-            const classDeclarations = this.jsvGetClassDeclarations(lazyClassNames, lazyClassAttributes);
-            for(const [propName, propValue] of Object.entries(classDeclarations)) {
-                const type = StyleDeclaration.JsvGetStyleType(propName);
-                changedTypes[type] = true;
-
-                if(typeof(propValue) === 'string' && propValue.startsWith('var(--')) {
-                    JsvStyleVariable.AppendRefStyle(propValue, this, propName);
-                }
-            }
-        }
-
-        // TODO: 文字class加速没有实现。
-        return changedTypes;
-    }
-
-    jsvSetChangedListener(listener) {
-        let callback = null;
-        if (listener) {
-            callback = (caches) => {
-                // console.log("StyleDeclaration.jsvSetChangedListener() keys=" + JSON.stringify(Object.keys(caches)))
-
-                if (caches.hasOwnProperty(StyleDeclaration.TYPE.CLASS_NAME)) {
-                    let changedTypes = this.jsvUpdateChangedClasses(this.jsvLazyClassNames,
-                        this.jsvLazyPrevClassNames,
-                        this.jsvLazyClassAttributes);
-                    Object.assign(caches, changedTypes);
-                    changedTypes = this.jsvUpdateChangedClasses(this.jsvLazyInheritedClassNames,
-                        this.jsvLazyPrevInheritedClassNames,
-                        this.jsvLazyClassAttributes);
-                    Object.assign(caches, changedTypes);
-
-                    caches[StyleDeclaration.TYPE.CLASS_NAME] = undefined;
-                }
-
-                listener(caches);
-            };
-        }
-        this.jsvLazySyncCache.setOnSyncCallback(callback);
-    }
-
-    static JsvContainsTextMajor(test_style) {
-        for (let major_style of StyleDeclaration.TextClassMajorStyles) {
-            if (test_style.hasOwnProperty(major_style))
-                return true;
-        }
-
-        return false;
-    }
-
-    static JsvGetStyleType(propName) {
-        switch(propName) {
-            case StyleDeclaration.PROP.LEFT:
-            case StyleDeclaration.PROP.RIGHT:
-            case StyleDeclaration.PROP.TOP:
-            case StyleDeclaration.PROP.BOTTOM:
-            case StyleDeclaration.PROP.ZINDEX:
-                return StyleDeclaration.TYPE.LAYOUT_POS;
-            case StyleDeclaration.PROP.TRANSFORM:
-            case StyleDeclaration.PROP.TRANSFORMORIGIN:
-                return StyleDeclaration.TYPE.TRANSFORM;
-            case StyleDeclaration.PROP.WIDTH:
-            case StyleDeclaration.PROP.HEIGHT:
-            case StyleDeclaration.PROP.VISIBILITY:
-            case StyleDeclaration.PROP.DISPLAY:
-            case StyleDeclaration.PROP.CLIPPATH:
-            case StyleDeclaration.PROP.OVERFLOW:
-            case StyleDeclaration.PROP.OBJECTFIT:
-            case StyleDeclaration.PROP.PERSPECTIVE:
-            case StyleDeclaration.PROP.PERSPECTIVEORIGIN:
-            case StyleDeclaration.PROP.BACKFACEVISIBILITY:
-            case StyleDeclaration.PROP.TRANSFORMSTYLE:
-            case StyleDeclaration.PROP.JSVVIDEOROTATION:
-                return StyleDeclaration.TYPE.LAYOUT_SIZE;
-            case StyleDeclaration.PROP.BACKGROUNDCOLOR:
-            case StyleDeclaration.PROP.BACKGROUNDIMAGE:
-            case StyleDeclaration.PROP.BORDERRADIUS:
-                return StyleDeclaration.TYPE.BACKGROUND;
-            case StyleDeclaration.PROP.COLOR:
-            case StyleDeclaration.PROP.LINEHEIGHT:
-            case StyleDeclaration.PROP.WHITESPACE:
-            case StyleDeclaration.PROP.FONTFAMILY:
-            case StyleDeclaration.PROP.FONTSIZE:
-            case StyleDeclaration.PROP.FONTSTYLE:
-            case StyleDeclaration.PROP.FONTWEIGHT:
-            case StyleDeclaration.PROP.TEXTALIGN:
-            case StyleDeclaration.PROP.TEXTSHADOW:
-            case StyleDeclaration.PROP.TEXTOVERFLOW:
-            case StyleDeclaration.PROP.WEBKITTEXTSTROKE:
-            case StyleDeclaration.PROP.DIRECTION:
-                return StyleDeclaration.TYPE.FOREGROUND;
-            case StyleDeclaration.PROP.BORDERIMAGE:
-            case StyleDeclaration.PROP.BORDERIMAGEWIDTH:
-            case StyleDeclaration.PROP.BORDERIMAGEOUTSET:
-                return StyleDeclaration.TYPE.BORDER;
-            case StyleDeclaration.PROP.ANIMATION:
-            // case StyleDeclaration.PROP.ANIMATIONNAME:
-            // case StyleDeclaration.PROP.ANIMATIONDURATION:
-            // case StyleDeclaration.PROP.ANIMATIONTIMINGFUNCTION:
-            // case StyleDeclaration.PROP.ANIMATIONDELAY:
-                return StyleDeclaration.TYPE.ANIMATION;
-            case StyleDeclaration.PROP.TRANSITION:
-                return StyleDeclaration.TYPE.TRANSITION;
-            case StyleDeclaration.PROP.OPACITY:
-                // TODO
-                break;
-            default:
-                console.warn("Unknown style type for: " + propName);
-                return null;
-        }
-    }
-
-    static JsvConvertPropValue(name, value) {
-        if(typeof(value) == 'undefined') {
-            return value;
-        }
-
-        if(name.startsWith('--')
-        || value?.startsWith?.('var(--')) {
-            return value;
-        }
-
-        switch (name) {
-        case StyleDeclaration.PROP.TOP:
-        case StyleDeclaration.PROP.BOTTOM:
-        case StyleDeclaration.PROP.LEFT:
-        case StyleDeclaration.PROP.RIGHT:
-        case StyleDeclaration.PROP.WIDTH:
-        case StyleDeclaration.PROP.HEIGHT:
-        case StyleDeclaration.PROP.JSVVIDEOROTATION:
-            return StyleValue.ConvertInt(value);
-        case StyleDeclaration.PROP.VISIBILITY:
-        case StyleDeclaration.PROP.DISPLAY:
-            return value.toUpperCase(); // 传入Forge需要大写，否则无效
-        case StyleDeclaration.PROP.OVERFLOW:
-            return StyleValue.ConvertOverflow(value, StyleDeclaration.Overflow);
-        case StyleDeclaration.PROP.OBJECTFIT:
-            return StyleValue.ConvertObjectFit(value, StyleDeclaration.ObjectFit);
-        case StyleDeclaration.PROP.TRANSFORM:
-            return value;
-        case StyleDeclaration.PROP.TRANSFORMORIGIN:
-            return value;
-        case StyleDeclaration.PROP.CLIPPATH:
-            return new Inset(value);
-        case StyleDeclaration.PROP.BORDERIMAGE:
-            return new BorderImage(value);
-        case StyleDeclaration.PROP.BORDERIMAGEWIDTH:
-        case StyleDeclaration.PROP.BORDERIMAGEOUTSET:
-            return StyleValue.ConvertRect(value);
-        case StyleDeclaration.PROP.BORDERRADIUS:
-            return StyleValue.ConvertCorner(value);
-        case StyleDeclaration.PROP.ANIMATION:
-            return StyleValue.ConvertAnimation(value);
-        case StyleDeclaration.PROP.TRANSITION:
-            return StyleValue.ConvertTransition(value);
-        case StyleDeclaration.PROP.OPACITY:
-            return StyleValue.ConvertFloat(value);
-        case StyleDeclaration.PROP.BACKGROUNDIMAGE:
-            return StyleValue.ConvertGradient(value);
-        default:
-            return StyleValue.ConvertPx(value);
-        }
-    }
-}
-
-StyleDeclaration.Overflow = {
-    HIDDEN    : Symbol('hidden'),
-    VISIBLE   : Symbol('visible'),
-};
-
-StyleDeclaration.ObjectFit = {
-    FILL      : Symbol('fill'),
-    CONTAIN   : Symbol('contain'),
-    COVER     : Symbol('cover'),
-    NONE      : Symbol('none'),
-    SCALEDOWN : Symbol('scale-down'),
-};
-
-StyleDeclaration.TextClassMajorStyles = new Set([
-    "textOverflow",
-    "wordWrap",
-    "textShadow",
-    // "fontSize", // fontSize为易变属性
-    // "lineHeight", // lineHeight同样为易变属性
-    "color",
-    "fontFamily",
-    "fontStyle",
-    "fontWeight",
-    "textAlign",
-    "WebkitTextStroke",
-    "direction",
-]);
-
-// type
-StyleDeclaration.TYPE = {
-    LAYOUT_POS  : 'layout-position',
-    LAYOUT_SIZE : 'layout-size',
-    FOREGROUND  : 'foreground',
-    BACKGROUND  : 'background',
-    BORDER      : 'border',
-    ANIMATION   : 'animation',
-    TRANSFORM   : 'transform',
-    TRANSITION  : 'transition',
-
-    CLASS_NAME  : 'class-name'
-};
-
-StyleDeclaration.PROP = {
-    // layout
-    TOP         : 'top',
-    BOTTOM      : 'bottom',
-    LEFT        : 'left',
-    RIGHT       : 'right',
-    WIDTH       : 'width',
-    HEIGHT      : 'height',
-    VISIBILITY  : 'visibility',
-    DISPLAY     : 'display',
-    BACKFACEVISIBILITY: "backfaceVisibility",
-    CLIPPATH    : 'clipPath',
-    OVERFLOW    : 'overflow',
-    OBJECTFIT   : 'objectFit',
-    TRANSFORM   : 'transform',
-    TRANSFORMORIGIN   : 'transformOrigin',
-    PERSPECTIVE : "perspective",
-    PERSPECTIVEORIGIN: "perspectiveOrigin",
-    ZINDEX      : 'zIndex',
-    TRANSFORMSTYLE: "transformStyle",
-
-    // background
-    BACKGROUNDCOLOR : 'backgroundColor',
-    BACKGROUNDIMAGE : 'backgroundImage',
-    BORDERRADIUS    : 'borderRadius',
-
-    // foreground
-    COLOR           : 'color',
-    LINEHEIGHT      : 'lineHeight',
-    WHITESPACE      : 'whiteSpace',
-    FONTFAMILY      : 'fontFamily',
-    FONTSIZE        : 'fontSize',
-    FONTSTYLE       : 'fontStyle',
-    FONTWEIGHT      : 'fontWeight',
-    TEXTALIGN       : 'textAlign',
-    TEXTSHADOW      : 'textShadow',
-    TEXTOVERFLOW    : 'textOverflow',
-    WEBKITTEXTSTROKE: 'WebkitTextStroke',
-    DIRECTON        : 'direction',
-
-
-    // border image: for ninepatch 
-    BORDERIMAGE      : 'borderImage',
-    BORDERIMAGEWIDTH : 'borderImageWidth',
-    BORDERIMAGEOUTSET: 'borderImageOutset',
-
-    // animation
-    ANIMATION               : "animation",
-    // ANIMATIONNAME           : "animationName",
-    // ANIMATIONDURATION       : "animationDuration",
-    // ANIMATIONTIMINGFUNCTION : "animationTimingFunction",
-    // ANIMATIONDELAY          : "animationDelay",
-    // ANIMATIONITERATIONCOUNT : "animationIterationCount",
-    // ANIMATIONDIRECTION      : "animationDirection",
-
-    // transition
-    TRANSITION               : "transition",
-    // TRANSITIONPROPERTY       : "transitionProperty",
-    // TRANSITIONDURATION       : "transitionDuration",
-    // TRANSITIONTIMINGFUNCTION : "transitionTimingFunction",
-    // TRANSITIONDELAY          : "transitionDelay",
-
-    // other unprocessed
-    OPACITY : "opacity",
-
-    JSVVIDEOROTATION: "JsvVideoRotation",
-};
-for(let key in StyleDeclaration.PROP) {
-    let propName = StyleDeclaration.PROP[key];
-    Object.defineProperty(StyleDeclaration.prototype, propName, {
-        set: function (value) {
-            this.setProperty(propName, value);
-        },
-        get: function () {
-            return this.getPropertyValue(propName);
-        }
-    })
-}
-
-export default StyleDeclaration;

package/dom/jsview-dom/src/dom-wrapper/style/StyleSheet.js

@@ -1,51 +0,0 @@
-/* eslint-disable no-extra-boolean-cast */
-import KeyframeRule from "./KeyframeRule";
-//import StyleValue from "./StyleValue";
-
-export default class StyleSheet {
-    constructor(content) {
-        this.jsvCssRules = null;
-        this.jsvTextContent = content;
-    }
-
-    get cssRules() {
-        if (!!this.jsvCssRules) {
-            return this.jsvCssRules;
-        }
-        this.jsvCssRules = new Array();
-
-        const firstKeyFramesIdx = this.jsvTextContent.indexOf(KeyframeRule.KeyFramesFlag);
-        if(firstKeyFramesIdx < 0) {
-            return this.jsvCssRules;
-        }
-        var contentArray = this.jsvTextContent.split(KeyframeRule.KeyFramesFlag)
-        for(let idx in contentArray) {
-            if(idx == 0) { // first item, is empty or invalid keyframes
-                continue;
-            }
-
-            this.insertRule(KeyframeRule.KeyFramesFlag + contentArray[idx]);
-        }
-
-        return this.jsvCssRules;
-    }
-
-    insertRule(rule, index) {
-        // console.log("StyleSheet.insertRule() rule=" + rule);
-        if (typeof index === 'undefined') {
-            index = this.jsvCssRules.length;
-        }
-
-        let keyFramesIdx = rule.indexOf(KeyframeRule.KeyFramesFlag);
-        if(keyFramesIdx < 0) {
-            throw Error("StyleSheet.insertRule() Rule is not supported except keyframes.");
-        }
-        let keyFrames = new KeyframeRule(rule);
-        this.jsvCssRules.splice(index, 0, keyFrames);
-    }
-
-    deleteRule(index) {
-        // console.log("StyleSheet.deleteRule() index=" + index);
-        this.jsvCssRules.splice(index, 1);
-    }
-}