@shijiu/jsview 1.9.719

package/dom/jsview-dom/src/engine-js/browser/url.js

@@ -0,0 +1,69 @@
+class URL {
+  constructor(value, parseTotal) {
+    this.href = '';
+    this.origin = '';
+    this.protocol = '';
+    this.host = '';
+    this.hostname = '';
+    this.port = '';
+    this.pathname = '';
+    this.search = '';
+    this.hash = '';
+    if (!value) {
+      return;
+    }
+    if (value.startsWith('url') === true) {
+      const startIdx = value.indexOf('(') + 1;
+      const endIdx = value.lastIndexOf(')');
+      value = value.substring(startIdx, endIdx).trim();
+    }
+
+    if (value.startsWith('data:') === true) {
+      this.href = value;
+      return;
+    }
+    if (value.startsWith('/') === true) {
+      value = document.location.origin + value;
+    }
+    if (value.startsWith('./') === true) {
+      const index = document.location.pathname.lastIndexOf("/");
+      let path = "";
+      if (index > 0) {
+        path = document.location.pathname.substring(0, index);
+      }
+      value = document.location.origin + path + value.substring(1);
+    }
+
+    this.href = value;
+    if (!parseTotal) {
+      return;
+    }
+
+    let idx = this.href.indexOf('?');
+    const protocolHostPath = (idx > 0 ? this.href.substring(0, idx) : this.href);
+    this.search = (idx > 1 ? this.href.substring(idx) : "");
+
+    idx = protocolHostPath.indexOf('://');
+    this.protocol = (idx > 0 ? protocolHostPath.substring(0, idx + 1) : "");
+    const hostPath = (idx > 1 ? protocolHostPath.substring(idx + 3) : "");
+
+    idx = hostPath.indexOf('/');
+    this.host = (idx > 0 ? hostPath.substring(0, idx) : "");
+    this.pathname = (idx > 1 ? hostPath.substring(idx) : "");
+    this.origin = (idx > 0 ? `${this.protocol}//${this.host}` : "");
+    // if(!this.origin) {
+    //     throw Error("Failed to parse total url.");
+    // }
+
+    idx = this.host.indexOf(':');
+    this.hostname = (idx > 0 ? this.host.substring(0, idx) : this.host);
+    this.port = (idx > 1 ? this.host.substring(idx + 1) : "");
+
+    console.log("create total parse URL, this=", this);
+  }
+
+  replace(newUrl) {
+    this.href = newUrl;
+  }
+}
+export default URL;

package/dom/jsview-dom/src/engine-js/browser/velocity.js

@@ -0,0 +1,40 @@
+/**
+ * Created by luocf on 2020/9/21.
+ */
+function Velocity() {
+  this.positionQueue = [];
+  this.timeQueue = [];
+}
+
+Velocity.prototype.reset = function() {
+  this.positionQueue = [];
+  this.timeQueue = [];
+};
+
+Velocity.prototype.pruneQueue = function(ms) {
+  // pull old values off of the queue
+  while (this.timeQueue.length && this.timeQueue[0] < (Date.now() - ms)) {
+    this.timeQueue.shift();
+    this.positionQueue.shift();
+  }
+};
+
+Velocity.prototype.updatePosition = function(position) {
+  this.positionQueue.push(position);
+  this.timeQueue.push(Date.now());
+  this.pruneQueue(50);
+};
+
+Velocity.prototype.getVelocity = function() {
+  this.pruneQueue(1000);
+  const length = this.timeQueue.length;
+  if (length < 2) return 0;
+
+  const time = (this.timeQueue[length - 1] - this.timeQueue[0]) / 1000;
+  const distance = this.positionQueue[length - 1] - this.positionQueue[0];
+
+  console.log(`getVelocity distance:${distance}， time：${time}, velocity:${distance / time}， this.timeQueue[length-1]：${this.timeQueue[length - 1]}, this.timeQueue[0]:${this.timeQueue[0]}`);
+  return distance / time;
+};
+
+export default Velocity;

package/dom/jsview-dom/src/engine-js/browser/view_sensor/autofroze_sensor.js

@@ -0,0 +1,77 @@
+import Forge from "../../ForgeDefine";
+
+{
+    /**********************************************
+     * Forge.sImpactSensorManager.AutoFroze
+     **********************************************/
+    class AutoFroze extends Forge.ViewSensor {
+        constructor(froze_pre_impact_views, froze_on_impact_views) {
+            // 此Sensor不需要回调
+            super(Forge.ViewSensor.TypeDefines.TYPE_FROZE_SET);
+
+            // Auto recycle 需要两个View list进行合并，所以对两个list都做记录(LayoutView的引用都要注意释放)
+            this._PreImpactViewList = null;
+            this._OnImpactViewList = null;
+
+            this._UpdateAutoRecycleRef(froze_pre_impact_views, true, froze_on_impact_views, true);
+
+            Forge.sViewSensorManager.AddSensor(this);
+        }
+
+        HtmlDoWorkOnFrame() {
+            // Nothing to do for AutoFroze(not supported for PC browser)
+        }
+
+        HtmlNeedWorkOnFrame() {
+            return false; // PC browser不需要触发每帧处理
+        }
+
+        UpdatePreImpactList(froze_pre_impact_views) {
+            this._UpdateAutoRecycleRef(froze_pre_impact_views, true, null, false);
+        }
+
+        UpdateOnImpactList(froze_on_impact_views) {
+            this._UpdateAutoRecycleRef(null, false, froze_on_impact_views, true);
+        }
+
+        // Hide public
+        DoRef() {
+            if (!this.Expired()) {
+                this._RefCount++;
+            } else {
+                console.error("Error: froze set is expired for all bind views lost");
+            }
+        }
+
+        // Hide public
+        UnRef() {
+            if (this._RefCount > 0) {
+                this._RefCount--;
+            }
+
+            if (this._RefCount == 0) {
+                this.Recycle();
+            }
+        }
+
+        // Override
+        OnSelfRecycle() {
+            this._PreImpactViewList = null;
+            this._OnImpactViewList = null;
+        }
+
+        _UpdateAutoRecycleRef(froze_pre_impact_views, pre_has_new_data, froze_on_impact_views, on_has_new_data) {
+            if (pre_has_new_data) {
+                this._PreImpactViewList = (froze_pre_impact_views instanceof Array ? froze_pre_impact_views : []);
+            }
+
+            if (on_has_new_data) {
+                this._OnImpactViewList = (froze_on_impact_views instanceof Array ? froze_on_impact_views : []);
+            }
+
+            // 合并view list
+            this.ResetAutoRecycleViewsRef([], [...this._PreImpactViewList, ...this._OnImpactViewList]);
+        }
+    }
+    Forge.sImpactSensorManager.AutoFroze = AutoFroze;
+}

package/dom/jsview-dom/src/engine-js/browser/view_sensor/drag_impact_sensor.js

@@ -0,0 +1,67 @@
+import Forge from "../../ForgeDefine";
+import getTransform from "../html_shared_tools/element_transform";
+import gjk from "../html_shared_tools/gjk";
+
+{
+    class DragImpactSensor extends Forge.ViewSensor {
+        constructor(element_array, element2, callback) {
+            super(Forge.ViewSensor.TypeDefines.TYPE_DRAG_IMPACT);
+
+            this._Callback = callback;
+
+            this._HtmlConfig = {
+                elementArray: element_array,
+                element2: element2,
+
+                // 内部碰撞状态记录
+                status: {
+                    contacted: false
+                }
+            }
+
+            // 无自动销毁的关联
+            this.ResetAutoRecycleViewsRef([], []);
+
+            // Add to sensor manager
+            Forge.sViewSensorManager.AddSensor(this);
+        }
+
+        HtmlDoWorkOnFrame() {
+            if (!this.Expired() && this._HtmlConfig.elementArray && this._HtmlConfig.element2) {
+                const element_array = this._HtmlConfig.elementArray;
+                const element2 = this._HtmlConfig.element2;
+
+                const ele_transform = getTransform(element2);
+                const intersected = gjk.intersect(element_array.slice(0, 1), ele_transform);
+                const intersected1 = gjk.intersect(element_array.slice(1, 2), ele_transform);
+                const intersected2 = gjk.intersect(element_array.slice(2, 3), ele_transform);
+                const intersected3 = gjk.intersect(element_array.slice(3, 4), ele_transform);
+                // console.log("intersected && intersected1 && intersected2 && intersected3:"+intersected+" , "+intersected1+" , "+intersected2 +" , "+intersected3, this._Element1, ele_transform);
+                if (!(intersected && intersected1 && intersected2 && intersected3)) {
+                    if (!this._HtmlConfig.status.contacted) {
+                        this._HtmlConfig.status.contacted = true;
+                        this.OnCallback({ status: 1, x: ele_transform[0], y: ele_transform[1] });
+                    }
+                } else {
+                    if (this._HtmlConfig.status.contacted) {
+                        this.OnCallback({ status: 2 });
+                        this._HtmlConfig.status.contacted = false;
+                    }
+                }
+            }
+        }
+
+        OnCallback(info) {
+            // console.log("TestImpact Docallback status=" + status);
+            if (this._Callback) {
+                if (info.status == 1 && this._Callback.OnBeginContact) {
+                    this._Callback.OnBeginContact(info.x, info.y);
+                } else if (info.status == 2 && this._Callback.OnEndContact) {
+                    this._Callback.OnEndContact();
+                }
+            }
+        }
+    }
+
+    Forge.DragImpactSensor = DragImpactSensor;
+}

package/dom/jsview-dom/src/engine-js/browser/view_sensor/impact_sensor.js

@@ -0,0 +1,98 @@
+/* eslint-disable */
+import Forge from "../../ForgeDefine";
+import testCollide from "../html_shared_tools/test_collide";
+
+{
+    /**********************************************
+     * Forge.ImpactSensor
+     **********************************************/
+
+    class ImpactSensor extends Forge.ViewSensor {
+        /**
+         * @public
+         * @constructor Forge.ImpactSensor
+         * @instance
+         * @param {Forge.LayoutView} view_1  碰撞源(LayoutView)
+         * @param {Forge.LayoutView} view_2  碰撞目标(LayoutView)
+         * @param {Forge.sImpactSensorManager.Callback} callback 碰撞状态变化的回调函数
+         * @param {Forge.sImpactSensorManager.AutoFroze} froze_views_set 碰撞状态变化时，将关联的View的动画先主动暂停，避免穿模
+         **/
+        constructor(view_1, view_2, callback, froze_views_set) {
+            super(Forge.ViewSensor.TypeDefines.TYPE_IMPACT);
+            
+            this._HtmlConfig = {
+                view1: view_1,
+                view2: view_2,
+
+                frozeSetId: froze_views_set ? froze_views_set.IdToken : 0, // HTML版本只记录，无法实现
+
+                // 内部碰撞状态记录
+                status: {
+                    contacted: false
+                }
+            }
+
+            this._Callback = callback;
+
+            // 处理FrozeViewsSet
+            this._FrozeViewsSet = froze_views_set;
+            if (froze_views_set) {
+                froze_views_set.DoRef();
+            }
+
+            // 登录自动销毁的关联LayoutView, 当view1或者view2销毁时，触发sensor自我销毁
+            this.ResetAutoRecycleViewsRef([view_1, view_2], []);
+
+            // Add to sensor manager
+            Forge.sViewSensorManager.AddSensor(this);
+        }
+
+        HtmlDoWorkOnFrame() {
+            if (!this.Expired() && this._HtmlConfig.view1 && this._HtmlConfig.view2) {
+                const intersected = testCollide(this._HtmlConfig.view1.Element, this._HtmlConfig.view2.Element);
+
+                if (intersected) {
+                    if (!this._HtmlConfig.status.contacted) {
+                        this._HtmlConfig.status.contacted = true;
+                        this.OnCallback(1);
+                    }
+                } else {
+                    if (this._HtmlConfig.status.contacted) {
+                        this.OnCallback(2);
+                        this._HtmlConfig.status.contacted = false;
+                    }
+                }
+            }
+        }
+
+        /**
+         * (Override) 触发碰撞回调
+         * @func DoCallback
+         * @memberof Forge.ImpactSensor
+         * @instance
+         * @param {int} status  1: collided  2: splited
+         **/
+        OnCallback(status) {
+            // console.log("TestImpact Docallback status=" + status);
+            if (this._Callback) {
+                if (status == 1 && this._Callback.OnBeginContact) {
+                    this._Callback.OnBeginContact();
+                } else if (status == 2 && this._Callback.OnEndContact) {
+                    this._Callback.OnEndContact();
+                }
+            }
+        }
+
+        // Override
+        OnSelfRecycle() {
+            // 取消对Froze set的引用，促使FrozeSet可释放
+            if (this._FrozeViewsSet) {
+                this._FrozeViewsSet.UnRef();
+                this._FrozeViewsSet = null;
+            }
+
+            this._HtmlConfig = null; // unref all, 释放内存
+        }
+    };
+    Forge.ImpactSensor = ImpactSensor;
+}

package/dom/jsview-dom/src/engine-js/browser/view_sensor/impact_sensor_callback.js

@@ -0,0 +1,21 @@
+import Forge from "../../ForgeDefine";
+
+{
+    /**********************************************
+     * Forge.sImpactSensorManager.Callback
+     **********************************************/
+    Forge.sImpactSensorManager.Callback = class {
+        constructor(on_begin_contact, on_end_contact) {
+            this.OnBeginContact = on_begin_contact;
+            this.OnEndContact = on_end_contact;
+        }
+
+        UpdateImpactCallback(on_begin_contact) {
+            this.OnBeginContact = on_begin_contact;
+        }
+
+        UpdateLeaveCallback(on_end_contact) {
+            this.OnEndContact = on_end_contact;
+        }
+    }
+}

package/dom/jsview-dom/src/engine-js/browser/view_sensor/impact_sensor_manager.js

@@ -0,0 +1,24 @@
+/* eslint-disable */
+import Forge from "../../ForgeDefine";
+
+{
+    /**********************************************
+     * Forge.sImpactSensorManager.ImpactSensorManager
+     **********************************************/
+    class ImpactSensorManager {
+        constructor() {
+
+        }
+
+        StartTrace(layout_view1, layout_view2, callback, froze_views_set) {
+            var sensor = new Forge.ImpactSensor(
+                layout_view1,
+                layout_view2,
+                callback,
+                froze_views_set);
+            return sensor;
+        };
+    };
+    
+    Forge.sImpactSensorManager = new ImpactSensorManager();
+}

package/dom/jsview-dom/src/engine-js/browser/view_sensor/index.js

@@ -0,0 +1,9 @@
+// 注意顺序，内部通过Forge全局注册进行关联，有登录顺序
+import "./view_sensor";
+import "./view_sensor_manager";
+import "./impact_sensor";
+import "./impact_sensor_manager";
+import "./autofroze_sensor";
+import "./impact_sensor_callback";
+import "./visible_sensor";
+

package/dom/jsview-dom/src/engine-js/browser/view_sensor/view_sensor.js

@@ -0,0 +1,268 @@
+/* eslint-disable */
+import Forge from "../../ForgeDefine";
+
+{
+
+    /**********************************************
+     * Forge.ViewSensor
+     **********************************************/
+
+    let CONST_TARGET_UNKNOWN = 1;
+    let CONST_TARGET_NEW_UPDATE = 2;
+    let CONST_TARGET_DELETE = 3;
+
+    class ViewSensor {
+        /**
+         * ViewSensor 构造函数
+         * 
+         * @param {Object} config sensor特殊的配置信息
+         */
+        constructor(type, config) {
+            /**
+             * Sensor有四种状态
+             * 1. 创建状态，target != DELETE, 未加入管理map
+             * 2. 未进管理map的删除状态, target == DELETE, 未加入管理map
+             * 3. Manger管理同步状态, target != DELETE, 加入了管理map, inSyncing = true
+             * 4. Manger管理同步完毕, target != DELETE, 加入了管理map, inSyncing = false
+             */
+
+            this.IdToken = Forge.sViewSensorManager.IdTokenGenerator++;
+
+            this.Type = type; // 标识是哪种扩展类
+
+            this.Manager = null;
+
+            // 自动清理关联的view
+            // any: 当列表中任意view释放后，就把自己expired掉
+            // all: 当列表中所有view释放后，就把自己expired掉
+            this._OnAnyViewLostList = null;
+            this._AnyViewLostMark = null;
+            this._OnWholeViewLostList = null;
+            this._WholeViewLostMark = null;
+
+            this._HtmlStatusInfo = {
+                target: config == null ? CONST_TARGET_UNKNOWN : CONST_TARGET_NEW_UPDATE,
+            }
+        }
+
+        OnManaged(manager) {
+            if (this._HtmlStatusInfo.target != CONST_TARGET_DELETE) {
+                if (!this.Manager) {
+                    // 对LayoutView进行是否在屏幕的监控
+                    this._RegisterViewLostCallbacks();
+
+                    this.Manager = manager;
+
+                    return true; // 非deleted装填，可以挂载
+                } else {
+                    // Already managed
+                    console.error("manage duplicated")
+                    return false;
+                }
+            }
+
+            return false; // 已经为delete状态，不能挂载
+        }
+
+        /**
+         * 重设 auto recycle view reference
+         * 
+         * @function ResetAutoRecycleViewsRef
+         * @param {Array} any_view_lost any: 当列表中任意view释放后，就把自己expired掉, 可以为[], 不能为null
+         * @param {Array} whole_views_lost all: 当列表中所有view释放后，就把自己expired掉, 可以为[], 不能为null
+         */
+        ResetAutoRecycleViewsRef(any_view_lost, whole_views_lost) {
+            if (!(any_view_lost instanceof Array) || !(whole_views_lost instanceof Array)) {
+                console.error("need array ", any_view_lost, whole_views_lost);
+                return;
+            }
+
+            if (this._HtmlStatusInfo.target != CONST_TARGET_DELETE) {
+                // 删除原本的跟踪点
+                this._UnregisterViewCallbacks();
+
+                // 使用新的跟踪点
+                this._OnAnyViewLostList = any_view_lost;
+                this._OnWholdViewLostList = whole_views_lost;
+
+                if (this.Manager) {
+                    // 已经被Manager管理后，立即触发View关联处理
+                    this._RegisterViewLostCallbacks();
+                }
+            } else {
+                // 处于删除状态，不做任何更新
+            }
+        }
+
+        Expired() {
+            return (this._HtmlStatusInfo.target == CONST_TARGET_DELETE);
+        }
+
+        Recycle() {
+            // 无论是否已经在同步队列中，只要从非delete变成delete状态则直接往删除队列中加
+            if (this._HtmlStatusInfo.target != CONST_TARGET_DELETE) {
+                if (this.Manager) {
+                    this._HtmlStatusInfo.target = CONST_TARGET_DELETE;
+
+                    this.OnSelfRecycle(); // 继承类资源回收
+
+                    this.Manager.RecycleSensor(this);
+                    this.Manager = null; // 将Manager置空，用于防止重复删除
+
+                    this._UnregisterViewCallbacks();
+                } else {
+                    // 未加入到任何manager, 不用做处理
+                }
+            } else {
+                // 已经处于回收完毕状态
+                // console.log("already recycled");
+            }
+
+            // 清理View引用，避免内存泄漏
+            this._OnAnyViewLostList = null;
+            this._OnWholdViewLostList = null;
+        }        
+
+        // Need override
+        HtmlDoWorkOnFrame() {
+            console.log("Need be override");
+        }
+
+        // 记录是否需要每一帧执行，默认是true(需要)
+        HtmlNeedWorkOnFrame() {
+            return true;
+        }
+
+        // Need override
+        OnCallback(params) {
+            console.log("Need be override");
+        }
+
+        // can override
+        OnSelfRecycle() {
+            // 当Recycle时被调用，继承类需要进行内部资源回收时进行override
+        }
+
+        _RegisterViewLostCallbacks() {
+            let that = this;
+
+            // Any的测算
+            if (this._OnAnyViewLostList?.length > 0) {
+                let list_length = this._OnAnyViewLostList.length;
+
+                this._AnyViewLostMark = {
+                    callbacks: new Array(list_length).fill(null),
+                };
+
+                // 创建View的detach回调
+                for (let view_idx = 0; view_idx < list_length; view_idx++) {
+                    let link_view = this._OnAnyViewLostList[view_idx];
+
+                    if (!link_view.Expired) {
+                        let callback = () => {
+                            // 有一个view detach后，sensor就自动recycle
+                            that.Recycle();
+                        };
+                        this._AnyViewLostMark.callbacks[view_idx] = callback
+                        link_view.RegisterDetachCallback(callback);
+                    } else {
+                        this._OnAnyViewLostList[view_idx] = null; // Unref expired view
+                    }
+                }
+            } else {
+                this._AnyViewLostMark = null;
+            }
+
+            // All的测算
+            if (this._OnWholeViewLostList?.length > 0) {
+                let list_length = this._OnWholeViewLostList.length;
+                // 重置统计 flags
+                this._WholeViewLostMark = {
+                    list: new Array(list_length).fill({
+                        callback: null,
+                        lost: false
+                    }),
+                    lostCount: 0
+                }
+
+                // 创建View的detach回调
+                for (let view_idx = 0; view_idx < list_length; view_idx++) {
+                    let link_view = this._OnWholeViewLostList[view_idx];
+
+                    if (!link_view.Expired) {
+                        // View有效，进行挂载(不用管是否已经再rootViewTree上)
+                        let callback = () => {
+                            // 全部view都lost后，sensor就自动recycle
+                            that._OnViewOfWholeListLost(view_idx);
+                        };
+                        this._WholeViewLostMark.list[view_idx].callback = callback
+                        link_view.RegisterDetachCallback(callback);
+                    } else {
+                        // 记录为失效view
+                        this._OnWholeViewLostList[view_idx] = null; // Unref expired view
+                        this._WholeViewLostMark.list[view_idx].lost = true;
+                        this._WholeViewLostMark.lostCount++;
+                    }
+                }
+            } else {
+                this._WholeViewLostMark = null;
+            }
+        }
+
+        _UnregisterViewCallbacks() {
+            // Any Lost list
+            if (this._AnyViewLostMark) {
+                let list_length = this._OnAnyViewLostList.length;
+                for (let view_idx = 0; view_idx < list_length; view_idx++) {
+                    let view = this._OnAnyViewLostList[view_idx];
+                    if (view) {
+                        this._OnAnyViewLostList[view_idx].UnregisterDetachCallback(
+                            this._AnyViewLostMark.callbacks[view_idx]
+                        );
+                    }
+                }
+
+                this._AnyViewLostMark = null;
+            }
+
+            // Whole lost list
+            if (this._WholeViewLostMark) {
+                let list_length = this._OnWholdViewLostList.length;
+                for (let view_idx = 0; view_idx < list_length; view_idx++) {
+                    let view = this._OnWholdViewLostList[view_idx];
+                    if (view) {
+                        this._OnWholdViewLostList[view_idx].UnregisterDetachCallback(
+                            this._WholeViewLostMark.list[view_idx].callback
+                        );
+                    }
+                }
+
+                this._WholeViewLostMark = null;
+            }
+        }
+
+        _OnViewOfWholeListLost(view_index) {
+            if (!this._WholeViewLostMark.list[view_index].lost) {
+                this._WholeViewLostMark.lostCount++;
+                this._WholeViewLostMark.list[view_index].lost = true;
+
+                this._WholeViewLostMark.list[view_idx].callback = null; // 清理callback, 减小内存
+                this._OnWholdViewLostList[view_index] = null; // Unref对layoutView的引用，避免内存泄漏
+            }
+
+            if (this._WholeViewLostMark.lostCount == this._OnWholeViewLostList.length) {
+                this.Recycle();
+            }
+        }
+    }
+
+    ViewSensor.TypeDefines = {
+        TYPE_IMPACT: 1,
+        TYPE_FROZE_SET: 2,
+        TYPE_ON_SCREEN: 3,
+
+        TYPE_DRAG_IMPACT: 101, // html专有
+    }
+
+    Forge.ViewSensor = ViewSensor;
+}