@rsmax/runtime 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+**Note:** Version bump only for package @rsmax/runtime

package/cjs/AppContainer.d.ts

@@ -0,0 +1,22 @@
+import VNode, { RawNode } from './VNode';
+import { FiberRoot } from 'react-reconciler';
+interface SpliceUpdate {
+    path: string;
+    start: number;
+    deleteCount: number;
+    items: RawNode[];
+}
+export default class AppContainer {
+    context: any;
+    root: VNode;
+    updateQueue: SpliceUpdate[];
+    _rootContainer?: FiberRoot;
+    constructor();
+    requestUpdate(path: string, start: number, deleteCount: number, ...items: RawNode[]): void;
+    applyUpdate(): void;
+    createCallback(name: string, fn: (...params: any) => any): void;
+    appendChild(child: VNode): void;
+    removeChild(child: VNode): void;
+    insertBefore(child: VNode, beforeChild: VNode): void;
+}
+export {};

package/cjs/AppContainer.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VNode_1 = __importDefault(require("./VNode"));
+const instanceId_1 = require("./instanceId");
+class AppContainer {
+    constructor() {
+        this.updateQueue = [];
+        this.root = new VNode_1.default({
+            id: (0, instanceId_1.generate)(),
+            type: 'root',
+            container: this,
+        });
+        this.root.mounted = true;
+    }
+    requestUpdate(path, start, deleteCount, ...items) {
+        // ignore
+    }
+    applyUpdate() {
+        this.context._pages.forEach((page) => {
+            page.container.applyUpdate();
+            page.modalContainer.applyUpdate();
+        });
+    }
+    createCallback(name, fn) {
+        this.context[name] = fn;
+    }
+    appendChild(child) {
+        this.root.appendChild(child);
+    }
+    removeChild(child) {
+        this.root.removeChild(child);
+    }
+    insertBefore(child, beforeChild) {
+        this.root.insertBefore(child, beforeChild);
+    }
+}
+exports.default = AppContainer;

package/cjs/Container.d.ts

@@ -0,0 +1,39 @@
+import VNode, { RawNode } from './VNode';
+import { FiberRoot } from 'react-reconciler';
+interface SpliceUpdate {
+    path: string[];
+    start: number;
+    id: number;
+    deleteCount: number;
+    items: RawNode[];
+    children?: RawNode[];
+    type: 'splice';
+    node: VNode;
+}
+interface SetUpdate {
+    path: string[];
+    name: string;
+    value: any;
+    type: 'set';
+    node: VNode;
+}
+export default class Container {
+    context: any;
+    root: VNode;
+    rootKey: string;
+    updateQueue: Array<SpliceUpdate | SetUpdate>;
+    _rootContainer?: FiberRoot;
+    stopUpdate?: boolean;
+    rendered: boolean;
+    constructor(context: any, rootKey?: string);
+    requestUpdate(update: SpliceUpdate | SetUpdate): void;
+    normalizeUpdatePath(paths: string[]): string;
+    applyUpdate(): void;
+    clearUpdate(): void;
+    createCallback(name: string, fn: (...params: any) => any): void;
+    removeCallback(name: string): void;
+    appendChild(child: VNode): void;
+    removeChild(child: VNode): void;
+    insertBefore(child: VNode, beforeChild: VNode): void;
+}
+export {};

package/cjs/Container.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VNode_1 = __importDefault(require("./VNode"));
+const instanceId_1 = require("./instanceId");
+const nativeEffect_1 = __importDefault(require("./nativeEffect"));
+const framework_shared_1 = require("@rsmax/framework-shared");
+const index_1 = require("./index");
+class Container {
+    constructor(context, rootKey = 'root') {
+        this.updateQueue = [];
+        this.rendered = false;
+        this.context = context;
+        this.root = new VNode_1.default({
+            id: (0, instanceId_1.generate)(),
+            type: 'root',
+            container: this,
+        });
+        this.root.mounted = true;
+        this.rootKey = rootKey;
+    }
+    requestUpdate(update) {
+        this.updateQueue.push(update);
+    }
+    normalizeUpdatePath(paths) {
+        return [this.rootKey, ...paths].join('.');
+    }
+    applyUpdate() {
+        if (this.stopUpdate || this.updateQueue.length === 0) {
+            return;
+        }
+        const startTime = new Date().getTime();
+        if (typeof this.context.$spliceData === 'function') {
+            let $batchedUpdates = (callback) => {
+                callback();
+            };
+            if (typeof this.context.$batchedUpdates === 'function') {
+                $batchedUpdates = this.context.$batchedUpdates;
+            }
+            $batchedUpdates(() => {
+                this.updateQueue.map((update, index) => {
+                    let callback = undefined;
+                    if (index + 1 === this.updateQueue.length) {
+                        callback = () => {
+                            nativeEffect_1.default.run();
+                            /* istanbul ignore next */
+                            if (framework_shared_1.RuntimeOptions.get('debug')) {
+                                console.log(`setData => 回调时间：${new Date().getTime() - startTime}ms`);
+                            }
+                        };
+                    }
+                    if (update.type === 'splice') {
+                        this.context.$spliceData({
+                            [this.normalizeUpdatePath([...update.path, 'children'])]: [
+                                update.start,
+                                update.deleteCount,
+                                ...update.items,
+                            ],
+                        }, callback);
+                    }
+                    if (update.type === 'set') {
+                        this.context.setData({
+                            [this.normalizeUpdatePath([...update.path, update.name])]: update.value,
+                        }, callback);
+                    }
+                });
+            });
+            this.updateQueue = [];
+            return;
+        }
+        const updatePayload = this.updateQueue.reduce((acc, update) => {
+            if (update.node.isDeleted()) {
+                return acc;
+            }
+            if (update.type === 'splice') {
+                acc[this.normalizeUpdatePath([...update.path, 'nodes', update.id.toString()])] = update.items[0] || null;
+                if (update.children) {
+                    acc[this.normalizeUpdatePath([...update.path, 'children'])] = (update.children || []).map(c => c.id);
+                }
+            }
+            else {
+                acc[this.normalizeUpdatePath([...update.path, update.name])] = update.value;
+            }
+            return acc;
+        }, {});
+        this.context.setData(updatePayload, () => {
+            nativeEffect_1.default.run();
+            /* istanbul ignore next */
+            if (framework_shared_1.RuntimeOptions.get('debug')) {
+                console.log(`setData => 回调时间：${new Date().getTime() - startTime}ms`, updatePayload);
+            }
+        });
+        this.updateQueue = [];
+    }
+    clearUpdate() {
+        this.stopUpdate = true;
+    }
+    createCallback(name, fn) {
+        this.context[name] = (...args) => {
+            return (0, index_1.unstable_batchedUpdates)(args => {
+                return fn(...args);
+            }, args);
+        };
+    }
+    removeCallback(name) {
+        delete this.context[name];
+    }
+    appendChild(child) {
+        this.root.appendChild(child);
+    }
+    removeChild(child) {
+        this.root.removeChild(child);
+    }
+    insertBefore(child, beforeChild) {
+        this.root.insertBefore(child, beforeChild);
+    }
+}
+exports.default = Container;

package/cjs/ReactPortal.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function createPortal(children: React.ReactNode, containerInfo: any, key?: string): any;

package/cjs/ReactPortal.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPortal = void 0;
+const react_is_1 = require("react-is");
+function createPortal(children, containerInfo, key) {
+    return {
+        // This tag allow us to uniquely identify this as a React Portal
+        $$typeof: react_is_1.Portal,
+        key: key || '',
+        children,
+        containerInfo,
+        implementation: null,
+    };
+}
+exports.createPortal = createPortal;

package/cjs/SyntheticEvent/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEPRECATED_CATCH_TYPE = "catchClick";
+export declare const SYNTHETIC_TYPES: string[];

package/cjs/SyntheticEvent/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNTHETIC_TYPES = exports.DEPRECATED_CATCH_TYPE = void 0;
+exports.DEPRECATED_CATCH_TYPE = 'catchClick';
+exports.SYNTHETIC_TYPES = [
+    'onClick',
+    'onTap',
+    'onLongClick',
+    'onLongTap',
+    'onTouchMove',
+    'onTouchStart',
+    'onTouchEnd',
+];

package/cjs/SyntheticEvent/createCallbackProxy.d.ts

@@ -0,0 +1,2 @@
+import VNode from '../VNode';
+export declare function createCallbackProxy(eventType: string, node: VNode, callback: (...params: any) => any): (...params: any) => any;

package/cjs/SyntheticEvent/createCallbackProxy.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCallbackProxy = void 0;
+const framework_shared_1 = require("@rsmax/framework-shared");
+const stopPropagation_1 = __importStar(require("./stopPropagation"));
+const constants_1 = require("./constants");
+function isSyntheticType(inputType) {
+    if (constants_1.DEPRECATED_CATCH_TYPE === inputType) {
+        console.warn('DEPRECATION: remax 已支持在 onClick 事件中使用 stopPropagation 阻止事件冒泡，请尽量不要使用 catchClick');
+    }
+    return !!(0, framework_shared_1.find)(constants_1.SYNTHETIC_TYPES, type => type === inputType);
+}
+function createBaseSyntheticEvent(node, eventType, nativeEvent) {
+    if (!nativeEvent) {
+        return;
+    }
+    // 添加阻止冒泡方法
+    nativeEvent.stopPropagation = () => {
+        (0, stopPropagation_1.default)(node, eventType);
+    };
+    return nativeEvent;
+}
+function createCallbackProxy(eventType, node, callback) {
+    if (!isSyntheticType(eventType)) {
+        return callback;
+    }
+    return function (nativeEvent, ...restParams) {
+        const syntheticEvent = createBaseSyntheticEvent(node, eventType, nativeEvent);
+        if (stopPropagation_1.isPropagationStopped[eventType]) {
+            (0, stopPropagation_1.validate)(node, eventType);
+            return;
+        }
+        return callback(syntheticEvent, ...restParams);
+    };
+}
+exports.createCallbackProxy = createCallbackProxy;

package/cjs/SyntheticEvent/stopPropagation.d.ts

@@ -0,0 +1,13 @@
+import VNode from '../VNode';
+export declare const isPropagationStopped: {
+    [key: string]: boolean;
+};
+/**
+ * 检查父元素里还有没有点击事件
+ *
+ * @export
+ * @param {VNode} node
+ * @returns
+ */
+export declare function validate(node: VNode, eventType: string): void;
+export default function stopPropagation(node: VNode, eventType: string): void;

package/cjs/SyntheticEvent/stopPropagation.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.isPropagationStopped = void 0;
+const constants_1 = require("./constants");
+exports.isPropagationStopped = {};
+constants_1.SYNTHETIC_TYPES.forEach(type => {
+    exports.isPropagationStopped[type] = false;
+});
+/**
+ * 检查父元素里还有没有点击事件
+ *
+ * @export
+ * @param {VNode} node
+ * @returns
+ */
+function validate(node, eventType) {
+    var _a;
+    const parent = node.parent;
+    if (!parent) {
+        exports.isPropagationStopped[eventType] = false;
+        return;
+    }
+    if ((_a = parent.props) === null || _a === void 0 ? void 0 : _a[eventType]) {
+        return;
+    }
+    validate(parent, eventType);
+}
+exports.validate = validate;
+function stopPropagation(node, eventType) {
+    exports.isPropagationStopped[eventType] = true;
+    validate(node, eventType);
+}
+exports.default = stopPropagation;

package/cjs/VNode.d.ts

@@ -0,0 +1,45 @@
+import Container from './Container';
+export interface RawNode {
+    id: number;
+    type: string;
+    props?: any;
+    nodes?: {
+        [key: number]: RawNode;
+    };
+    children?: Array<RawNode | number>;
+    text?: string;
+}
+export default class VNode {
+    id: number;
+    container: Container;
+    mounted: boolean;
+    deleted: boolean;
+    type: string;
+    props?: any;
+    parent: VNode | null;
+    firstChild: VNode | null;
+    lastChild: VNode | null;
+    size: number;
+    previousSibling: VNode | null;
+    nextSibling: VNode | null;
+    text?: string;
+    callbackIds: Set<string>;
+    constructor({ id, type, props, container }: {
+        id: number;
+        type: string;
+        props?: any;
+        container: any;
+    });
+    appendChild(node: VNode): void;
+    removeChild(node: VNode): void;
+    insertBefore(node: VNode, referenceNode: VNode): void;
+    update(payload?: any[]): void;
+    get index(): number;
+    get children(): VNode[];
+    get path(): string[];
+    isMounted(): boolean;
+    isDeleted(): boolean;
+    registerCallback(propKey: string, propValue: any): string;
+    unregisteredCallbacks(): void;
+    toJSON(): RawNode;
+}