@shijiu/jsview 1.9.719

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

@@ -0,0 +1,84 @@
+/* eslint-disable */
+import Forge from "../../ForgeDefine";
+
+{
+    const ACK_EVENT_ID_ARRAY = "ID";
+    const ACK_EVENT_STATUS_ARRAY = "STA";
+
+    /**********************************************
+     * Forge.sViewSensorManager
+     **********************************************/
+    class ViewSensorManager {
+        constructor() {
+            this._SensorMaps = {};
+            this.IdTokenGenerator = 77;
+        }
+
+        HtmlDoWorkOnFrame() {
+            for (let key in this._SensorMaps) {
+                let sensor = this._SensorMaps[key];
+                if (sensor.Expired()) {
+                    delete this._SensorMaps[key];
+                } else {
+                    sensor.HtmlDoWorkOnFrame();
+                }
+            }
+        }
+
+        HtmlHasActiveSensor() {
+            for (let key in this._SensorMaps) {
+                if (this._SensorMaps[key].HtmlNeedWorkOnFrame()) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /**
+         * 激活一个View Sensor(加入Render端同步队列)
+         * @param {Forge.ViewSensor} view_sensor  需要激活的sensor
+         */
+        AddSensor(view_sensor) {
+            if (view_sensor) {
+                let valid = view_sensor.OnManaged(this); // 进行挂载
+                if (valid) {
+                    this._SensorMaps[view_sensor.IdToken] = view_sensor; // 加入map管理
+                }
+
+                this.RequestSwap();
+            }
+        }
+
+        /**
+         * 内部函数，把一个View Sensor加入Render端同步列表中
+         * @param {Forge.ViewSensor} view_sensor  需要激活的sensor
+         */
+        AddToSyncList(view_sensor) {
+            if (this._SensorMaps.hasOwnProperty(view_sensor.IdToken)) {
+            } else {
+                console.error("Error: (Add)No in map", this._SensorMaps, view_sensor);
+            }
+        }
+
+        /**
+         * 内部函数，删除一个View Sensor(加入Render端删除队列)
+         * @param {Forge.ViewSensor} view_sensor  需要删除的sensor
+         */
+        RecycleSensor(view_sensor) {
+            if (this._SensorMaps.hasOwnProperty(view_sensor.IdToken)) {
+                delete this._SensorMaps[view_sensor.IdToken];
+
+                this.RequestSwap();
+            } else {
+                console.error("Error: (del)No in map", this._SensorMaps, view_sensor);
+            }
+        }
+
+        RequestSwap() {
+            Forge.sRenderBridge.BeginHtmlFrameLoop(); // Html版本触发屏幕刷新
+            // Forge.sRenderBridge.RequestSwap(); // 触发Layout同步处理，促使屏幕刷新
+        }
+    }
+
+    Forge.sViewSensorManager = new ViewSensorManager();
+}

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

@@ -0,0 +1,213 @@
+import Forge from "../../ForgeDefine";
+import { getCoverSize } from "../html_shared_tools/element_transform";
+import { SingleRangeModel } from "../html_shared_tools/range_model";
+
+{
+    const ACK_EVENT_OLD_VERTICAL_VISIBLE = "OV";
+    const ACK_EVENT_NEW_VERTICAL_VISIBLE = "NV";
+    const ACK_EVENT_OLD_HORIZONTAL_VISIBLE = "OH";
+    const ACK_EVENT_NEW_HORIZONTAL_VISIBLE = "NH";
+
+    class VisibleSensor extends Forge.ViewSensor {
+        /***********************************
+         * target_layout_view:   Forge.LayoutView
+         * callback: function(old_hor_visible, new_hor_visible, old_ver_visible, new_ver_visible)  横向的可见状态，纵向的可见状态
+         **********************************/
+        constructor(test_view, callback) {
+            super(Forge.ViewSensor.TypeDefines.TYPE_ON_SCREEN);
+
+            this._HtmlConfig = {
+                view: test_view,
+                container: null,
+                enable: false, // 默认不开启
+
+                testRange: null,
+
+                // 内部碰撞状态记录
+                status: {
+                    horizonVisible: false,
+                    verticalVisible: false
+                }
+            }
+
+            this._Callback = callback;
+
+            // 登录自动销毁的关联LayoutView, 当view1或者view2销毁时，触发sensor自我销毁
+            this.ResetAutoRecycleViewsRef([test_view], []);
+
+            // Add to sensor manager
+            Forge.sViewSensorManager.AddSensor(this);
+        }
+
+        // override
+        HtmlDoWorkOnFrame() {
+            if (!this.Expired() && this._HtmlConfig.enable
+                    && this._HtmlConfig.testRange && this._HtmlConfig.view) {
+                let designe_width = Forge.sRenderBridge.GetScreenInfo().designedWidth;
+                let designe_height = Math.floor(designe_width * 9 / 16); // 默认按照16:9假定PC上的显示区域
+
+                // 计算view的位置信息
+                let view_rect = {
+                    top: 0,
+                    bottom: 0,
+                    left: 0,
+                    right: 0
+                };
+                let ele_cover = getCoverSize(this._HtmlConfig.view.Element);
+                [view_rect.top, view_rect.bottom, view_rect.left, view_rect.right] = ele_cover;
+
+                // 计算container的位置信息
+                let container_rect = {
+                    top: 0,
+                    bottom: designe_height,
+                    left: 0,
+                    right: designe_width
+                };
+                let container_visible = true; // container为可视时才算可视, 默认container为全屏, 所以默认container可视
+                let container_h_range;
+                let container_v_range;
+                if (this._HtmlConfig.container) {
+                    let container_cover = getCoverSize(this._HtmlConfig.container.Element);
+                    [
+                        container_rect.top,
+                        container_rect.bottom,
+                        container_rect.left,
+                        container_rect.right
+                    ] = container_cover;
+
+                    // 检测container是否可视
+                    container_h_range = new SingleRangeModel(container_rect.left, container_rect.right);
+                    container_v_range = new SingleRangeModel(container_rect.top, container_rect.bottom);
+                    let screen_h_range = new SingleRangeModel(0, designe_width);
+                    let screen_v_range = new SingleRangeModel(0, designe_height);
+                    // 只要一小部分可视，即为可视
+                    container_visible = screen_h_range.IsInterAct(container_h_range)
+                        && screen_v_range.IsInterAct(container_v_range);
+                } else {
+                    container_h_range = new SingleRangeModel(container_rect.left, container_rect.right);
+                    container_v_range = new SingleRangeModel(container_rect.top, container_rect.bottom);
+                }
+
+                // 计算visible test range
+                let fullview_h_range = new SingleRangeModel(view_rect.left, view_rect.right);
+                let fullview_v_range = new SingleRangeModel(view_rect.top, view_rect.bottom);
+                let view_h_left_range;
+                let view_h_right_range;
+                let view_v_top_range;
+                let view_v_bottom_range;
+                let test_range = this._HtmlConfig.testRange;
+                {
+                    let length = Math.floor((view_rect.right - view_rect.left) * test_range.horizon);
+                    view_h_left_range = new SingleRangeModel(
+                        view_rect.left,
+                        view_rect.left + length);
+                    
+                    view_h_right_range = new SingleRangeModel(
+                        view_rect.right - length,
+                        view_rect.right);
+                }
+                {
+                    let length = Math.floor((view_rect.bottom - view_rect.top) * test_range.vertical);
+                    view_v_top_range = new SingleRangeModel(
+                        view_rect.top,
+                        view_rect.top + length);
+                    
+                    view_v_bottom_range = new SingleRangeModel(
+                        view_rect.bottom - length,
+                        view_rect.bottom);
+                }
+                
+                // 进行可视校验
+                let h_visible =
+                    (container_h_range.IsInclude(view_h_left_range)
+                        || container_h_range.IsInclude(view_h_right_range))
+                    && container_v_range.IsInterAct(fullview_v_range) // view在container可见
+                    && container_visible; // 横向范围可见，纵向部分可见
+                let v_visible =
+                    (container_v_range.IsInclude(view_v_top_range) 
+                        || container_v_range.IsInclude(view_v_bottom_range))
+                    && container_h_range.IsInterAct(fullview_h_range) // view在container可见
+                    && container_visible; // 纵向范围可见，横向部分可见
+                if (h_visible != this._HtmlConfig.status.horizonVisible
+                    || v_visible != this._HtmlConfig.status.verticalVisible) {
+                    let ack = {};
+                    ack[ACK_EVENT_OLD_HORIZONTAL_VISIBLE] = this._HtmlConfig.status.horizonVisible;
+                    ack[ACK_EVENT_NEW_HORIZONTAL_VISIBLE] = h_visible;
+                    ack[ACK_EVENT_OLD_VERTICAL_VISIBLE] = this._HtmlConfig.status.verticalVisible;
+                    ack[ACK_EVENT_NEW_VERTICAL_VISIBLE] = v_visible;
+
+                    this._HtmlConfig.status.horizonVisible = h_visible;
+                    this._HtmlConfig.status.verticalVisible = v_visible;
+
+                    this.OnCallback(ack);
+                }
+            }
+        }
+
+        // 记录是否需要每一帧执行，默认是true(需要)
+        HtmlNeedWorkOnFrame() {
+            return this._HtmlConfig.enable;
+        }
+
+        HtmlRequestSync() {
+            Forge.sRenderBridge.BeginHtmlFrameLoop(); // Html版本触发屏幕刷新
+        }
+
+        /***********************************
+         * area:  {horizon, verical} 
+         *      露出百分比触发状态切换的阀值，当可视区域大于或等于给定可视区域时，可视状态切换
+         *      默认为0: 当有一点点被遮挡则为'不可见'状态，完全露出后才变为'可见状态'
+         *      一个坐标轴，只能有一个设置，另一个应该为0                  
+         **********************************/
+        ResetArea(area) {
+            if (typeof area.horizon != "number") {
+                console.log("horizon not set, default to 1.0");
+                area.horizon = 1.0;
+            }
+
+            if (typeof area.vertical != "number") {
+                console.log("vertical not set, default to 1.0");
+                area.vertical = 1.0;
+            }
+
+            this._HtmlConfig.testRange = area;
+
+            this.HtmlRequestSync();
+        }
+
+        Enable(to_enable) {
+            this._HtmlConfig.enable = to_enable;
+            this.HtmlRequestSync();
+        }
+
+        ResetContainer(container_layout_view) {
+            this._HtmlConfig.container = container_layout_view;
+
+            this.HtmlRequestSync();
+        }
+
+        /**
+         * (Override) 触发碰撞回调，当状态变化时被回调
+         * @func OnCallback
+         * @param {object} status {OH:xxx, NH:xxx, OV:xxx, NV:xxx}
+         **/
+        OnCallback(status) {
+            // console.log("TestImpact Docallback status=" + status);
+            if (this._Callback) {
+                this._Callback(
+                    status[ACK_EVENT_OLD_HORIZONTAL_VISIBLE],
+                    status[ACK_EVENT_NEW_HORIZONTAL_VISIBLE],
+                    status[ACK_EVENT_OLD_VERTICAL_VISIBLE],
+                    status[ACK_EVENT_NEW_VERTICAL_VISIBLE]
+                );
+            }
+        }
+
+        // Override
+        OnSelfRecycle() {
+            this._HtmlConfig = null; // unref all, 释放内存
+        }
+    }
+
+    Forge.VisibleSensor = VisibleSensor;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Created by luocf on 2020/3/26.
+ */
+import Forge from "../ForgeDefine";
+
+class ViewStore {
+  constructor() {
+    this._InnerViews = {};
+    this._ViewToken = 1;  // 避免从0开始导致，0为基础无效值
+  }
+
+  add(view_info) {
+    const view_token = ++this._ViewToken;
+    this._InnerViews[`${view_token}`] = view_info;
+    return view_token;
+  }
+
+  remove(view_token) {
+    if (this._InnerViews[view_token]) {
+      delete this._InnerViews[view_token];
+    }
+  }
+
+  get(view_token) {
+    return this._InnerViews[view_token];
+  }
+
+  clear() {
+    this._InnerViews = {};
+    this._ViewToken = 1; // 避免从0开始导致，0为基础无效值
+  }
+}
+Forge.ViewStore = ViewStore;
+Forge.sViewStore = new ViewStore();
+class ViewInfo {
+  constructor(view, layout_params) {
+    this.view = view;
+    this.layout_params = layout_params;
+  }
+}
+Forge.ViewInfo = ViewInfo;

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

@@ -0,0 +1,2 @@
+export {default as ForgeExtension} from "./ForgeExtensionDefine"
+export {default as Forge} from "./ForgeDefine"

package/dom/jsview-dom/src/engine-js/native/README.md

@@ -0,0 +1 @@
+Engine-js Native部分集成外部工程forge-all中，作为engineJs被android的apk预先加载

package/dom/target_core_revision.mjs

@@ -0,0 +1,15 @@
+/**
+ * Created by ludl on 1/27/21.
+ */
+
+const TargetRevision = {
+  "CoreRevision": 1021230,
+  "CoreRevisionAndBranch": "1021230",
+  "JseRevision": "1.0.824",
+  "JseUrl":
+    "http://cdn.release.qcast.cn/forge_js/master/JsViewES6_react_r824.jsv.a2da4803.js"
+};
+
+// 不要用export default，update-env脚本不能解析
+// module.exports = TargetRevision;
+export default TargetRevision;

package/loader/header_script_loader.js

@@ -0,0 +1,134 @@
+/**
+ * Created by ludl on 3/30/20.
+ */
+
+function alterUrl(origin_url, js_sub_path) {
+  console.log(`++++++++ origin_url=${origin_url} js_sub_path = ${js_sub_path}`);
+  let schema_idx = origin_url.indexOf("://");
+  if (schema_idx < 0 || schema_idx > 10) {
+    // 非schema打头方式，认为是相对路径
+    if (!origin_url.startsWith('./') && !origin_url.startsWith('/')) {
+      origin_url = "./" + origin_url; // 补充相对路径头信息
+    }
+  }
+
+  if (origin_url.startsWith('./') || origin_url.startsWith('/')) {
+    const main_js_path = window.JsView.getAppUrl();
+    let idx = main_js_path.indexOf('?');
+    const host_path = (idx > 0 ? main_js_path.substring(0, idx) : main_js_path);
+    idx = host_path.lastIndexOf(js_sub_path);
+    const path_header = host_path.substring(0, idx);
+
+    let ret;
+    if (origin_url.startsWith('./')) {
+      ret = path_header + origin_url.substring(1);
+    } else {
+      // start with '/'
+      // remove protocal
+      let host_parser = main_js_path;
+      idx = host_parser.indexOf('://');
+      const protocol = (idx > 0 ? host_parser.substring(0, idx) : "");
+      host_parser = (idx > 1 ? host_parser.substring(idx + 3) : "");
+
+      // Get host
+      idx = host_parser.indexOf('/');
+      const host = (idx > 0 ? host_parser.substring(0, idx) : "");
+
+      ret = `${protocol}://${host}${origin_url}`;
+    }
+
+    return ret;
+  }
+  return origin_url;
+}
+
+class LoadingScriptElement {
+  constructor(js_sub_path) {
+    console.log(`++++++++ js_sub_path=${js_sub_path}`);
+    this.src = null;
+    this.onerror = null;
+    this.onload = null;
+    this.charset = null;
+    this.timeout = 120;
+    this._JsSubPath = js_sub_path;
+  }
+
+  setAttribute(name, value) {
+    console.log(`ScriptElement.setAttribute() name=${name}, value=`, value);
+    this[name] = value;
+  }
+
+  jsvActiveScript() {
+    if (this.src !== null) {
+      const url_href = alterUrl(this.src, this._JsSubPath);
+      console.log(`load script with url=${url_href}`);
+      const _this = this;
+      window.JsView.runJsWithUrl(url_href, false, (is_success, err_code) => {
+        _this.onLoadResult(is_success, err_code);
+      });
+    }
+  }
+
+  onLoadResult(is_success, err_code) {
+    console.log(`[Head]onLoadResult ${is_success} ${err_code}`);
+    if (is_success) {
+      if (this.onload) {
+        this.onload();
+      }
+    } else {
+      if (this.onerror) {
+        this.onerror({ type: `[Head]jsvErr_${err_code}`, target: this });
+      }
+    }
+  }
+}
+
+class LoadingHeader {
+  constructor() {
+    console.log("Document header construct");
+  }
+
+  appendChild(node) {
+    if (node instanceof LoadingScriptElement) {
+      console.log("Found append script in head.");
+      node.jsvActiveScript();
+    }
+  }
+}
+
+class LoadingDocument {
+  constructor(js_sub_path) {
+    this.head = new LoadingHeader();
+    this._JsSubPath = js_sub_path;
+  }
+
+  createElement(name) {
+    console.log(`HeaderDocument.createElement() name=${name}`);
+    switch (name) {
+      case "script":
+        return new LoadingScriptElement(this._JsSubPath);
+      default:
+        console.warn(`HeaderDocument.createElement() name=${name}`);
+        return null;
+    }
+  }
+
+  getElementsByTagName(name) {
+    if (name.toLowerCase() === "head") {
+      return [this.head];
+    }
+    if (name.toLowerCase() === "link"
+      || name.toLowerCase() === "script"
+      || name.toLowerCase() === "style") {
+      return [];
+    }
+
+    throw Error("LoadingDocument.getElementsByTagName() name=" + name + " is UNIMPLEMENTED.");
+  }
+}
+
+function initHeaderScriptLoader(js_sub_path) {
+  window.document = new LoadingDocument(js_sub_path);
+}
+
+export default initHeaderScriptLoader;

package/loader/jsview-main.js

@@ -0,0 +1,42 @@
+import JsViewDefConfig from "./jsview.default.config"
+import JsViewVendorConfig from "/src/appConfig/jsview.config"
+import { loadJsViewEnv } from './loader'
+
+function deepMerge(target, source) {
+  const isObject = (obj) => obj && typeof obj === 'object';
+
+  if (!isObject(target) || !isObject(source)) {
+    return source;
+  }
+
+  Object.keys(source).forEach(key => {
+    const targetValue = target[key];
+    const sourceValue = source[key];
+
+    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+      target[key] = targetValue.concat(sourceValue);
+    } else if (isObject(targetValue) && isObject(sourceValue)) {
+      target[key] = deepMerge(Object.assign({}, targetValue), sourceValue);
+    } else {
+      target[key] = sourceValue;
+    }
+  });
+
+  return target;
+}
+
+function main() {
+    // 使用vendor配置值覆盖默认配置。
+    let config = JsViewDefConfig;
+    deepMerge(config, JsViewVendorConfig);
+    console.log("JsView config: " + JSON.stringify(config));
+
+    // 加载jsview运行环境。
+    loadJsViewEnv(config, () => {
+        // JsView环境加载完毕后，加载vue/react的main.js文件。
+        import('/src/main.tsx');
+    })
+}
+
+// webpack/vite运行入口
+main();

package/loader/jsview.config.default.js

@@ -0,0 +1,37 @@
+export default {
+    jsviewConfig: {
+        // (可选配置)localStorage支持
+        // domain可以为任意字符串，各Domain的localStorage互相隔离, 默认值是hostname
+        // presetKeys为预置key，可以直接使用localStorage.xxx的形式，避免undefined错误
+        localStorage: {
+            domain: "default",
+            presetKeys: [
+                "value1",
+                "value2"
+            ],
+        },
+
+        // (可选配置)填写main.js或者bundle.js相对于index.html的相对位置，
+        // 用于image/import.then的相对寻址, vue3默认值是/js/
+        jsSubPath: "/js/",
+    },
+
+    vendorConfig: {
+        // (可选配置)设置屏幕坐标映射值，screenWidth为屏幕画布定义的宽度，displayScale为清晰度，
+        // 默认值是画布宽度1280px, 清晰度为1.0
+        designedMap: {
+            screenWidth: 1280,
+            displayScale: 1.0
+        },
+
+        // (可选配置)按键接受的扩展，例如将静音按键(JAVA键值为164)映射为JS键值20001，
+        // PS:注意"164"的引号
+        bindKeys: {
+            keys: {
+                "164": 20001
+            },
+            syncKeys: {
+            }
+        },
+    }
+}

package/loader/jsview.default.config.js

@@ -0,0 +1,37 @@
+export default {
+    jsviewConfig: {
+        // (可选配置)localStorage支持
+        // domain可以为任意字符串，各Domain的localStorage互相隔离, 默认值是hostname
+        // presetKeys为预置key，可以直接使用localStorage.xxx的形式，避免undefined错误
+        localStorage: {
+            domain: "default",
+            presetKeys: [
+                "value1",
+                "value2"
+            ],
+        },
+
+        // (可选配置)填写main.js或者bundle.js相对于index.html的相对位置，
+        // 用于image/import.then的相对寻址, vue3默认值是/js/
+        jsSubPath: "/js/",
+    },
+
+    vendorConfig: {
+        // (可选配置)设置屏幕坐标映射值，screenWidth为屏幕画布定义的宽度，displayScale为清晰度，
+        // 默认值是画布宽度1280px, 清晰度为1.0
+        designedMap: {
+            screenWidth: 1280,
+            displayScale: 1.0
+        },
+
+        // (可选配置)按键接受的扩展，例如将静音按键(JAVA键值为164)映射为JS键值20001，
+        // PS:注意"164"的引号
+        bindKeys: {
+            keys: {
+                "164": 20001
+            },
+            syncKeys: {
+            }
+        },
+    }
+}