@rsmax/runtime 1.0.1

package/cjs/polyfills/Function.js

@@ -0,0 +1,29 @@
+"use strict";
+/* eslint-disable prefer-rest-params */
+/* istanbul ignore next */
+if (typeof Function.prototype.call === 'undefined') {
+    Function.prototype.call = function (context) {
+        context = context || window;
+        context.fn = this;
+        const args = [...arguments].slice(1);
+        const result = context.fn(...args);
+        delete context.fn;
+        return result;
+    };
+}
+/* istanbul ignore next */
+if (typeof Function.prototype.apply === 'undefined') {
+    Function.prototype.apply = function (context) {
+        context = context || window;
+        context.fn = this;
+        let result;
+        if (arguments[1]) {
+            result = context.fn(...arguments[1]);
+        }
+        else {
+            result = context.fn();
+        }
+        delete context.fn;
+        return result;
+    };
+}

package/cjs/propsAlias.d.ts

@@ -0,0 +1,6 @@
+export declare function getAlias(prop: string, type: string): string;
+export interface GenericProps {
+    [key: string]: any;
+}
+export declare function propAlias(prop: string, value: any, type: string): any[];
+export default function propsAlias(props: GenericProps, type: string): GenericProps;

package/cjs/propsAlias.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propAlias = exports.getAlias = void 0;
+const plainStyle_1 = __importDefault(require("./utils/plainStyle"));
+const framework_shared_1 = require("@rsmax/framework-shared");
+function getAlias(prop, type) {
+    var _a, _b;
+    const hostComponent = framework_shared_1.RuntimeOptions.get('hostComponents')[type];
+    const prefix = `${framework_shared_1.RuntimeOptions.get('platform')}-`;
+    // 判断是否是平台独有属性
+    if (prop.startsWith(prefix)) {
+        return prop.replace(new RegExp(`^${prefix}`), '');
+    }
+    return (_b = (_a = hostComponent === null || hostComponent === void 0 ? void 0 : hostComponent.alias) === null || _a === void 0 ? void 0 : _a[prop]) !== null && _b !== void 0 ? _b : prop;
+}
+exports.getAlias = getAlias;
+function getValue(prop, value) {
+    if (prop.toLowerCase().endsWith('style') && Object.prototype.toString.call(value) === '[object Object]') {
+        return (0, plainStyle_1.default)(value);
+    }
+    return value;
+}
+function propAlias(prop, value, type) {
+    return [getAlias(prop, type), getValue(prop, value)];
+}
+exports.propAlias = propAlias;
+function propsAlias(props, type) {
+    if (!props) {
+        return props;
+    }
+    const prefix = `${framework_shared_1.RuntimeOptions.get('platform')}-`;
+    const aliasProps = {};
+    for (const prop in props) {
+        // 平台前缀属性优先级提升
+        // @see https://github.com/remaxjs/remax/issues/1409
+        const hasPrefix = prop.startsWith(prefix);
+        const key = getAlias(prop, type);
+        const value = getValue(prop, props[prop]);
+        if (hasPrefix) {
+            aliasProps[key] = value;
+        }
+        else {
+            aliasProps[key] = aliasProps[key] || value;
+        }
+    }
+    return aliasProps;
+}
+exports.default = propsAlias;

package/cjs/render.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import ReactReconciler from 'react-reconciler';
+import Container from './Container';
+import AppContainer from './AppContainer';
+export declare const ReactReconcilerInst: ReactReconciler.Reconciler<unknown, unknown, unknown, unknown, unknown>;
+export default function render(rootElement: React.ReactElement | null, container: Container | AppContainer): any;

package/cjs/render.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactReconcilerInst = void 0;
+const react_reconciler_1 = __importDefault(require("react-reconciler"));
+const hostConfig_1 = __importDefault(require("./hostConfig"));
+exports.ReactReconcilerInst = (0, react_reconciler_1.default)(hostConfig_1.default);
+if (process.env.NODE_ENV === 'development') {
+    exports.ReactReconcilerInst.injectIntoDevTools({
+        bundleType: 1,
+        version: '18.3.0',
+        rendererPackageName: 'remax',
+    });
+}
+function getPublicRootInstance(container) {
+    const containerFiber = container.current;
+    if (!containerFiber.child) {
+        return null;
+    }
+    return containerFiber.child.stateNode;
+}
+function render(rootElement, container) {
+    // Create a root Container if it doesnt exist
+    if (!container._rootContainer) {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        container._rootContainer = exports.ReactReconcilerInst.createContainer(container, 0, null, false, null, '', () => { }, null);
+    }
+    exports.ReactReconcilerInst.updateContainer(rootElement, container._rootContainer, null, () => {
+        // ignore
+    });
+    return getPublicRootInstance(container._rootContainer);
+}
+exports.default = render;

package/cjs/stopPullDownRefresh/index.ali.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/cjs/stopPullDownRefresh/index.ali.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = my.stopPullDownRefresh;

package/cjs/stopPullDownRefresh/index.d.ts

@@ -0,0 +1 @@
+export default function stopPullDownRefresh(): void;

package/cjs/stopPullDownRefresh/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function stopPullDownRefresh() {
+    // do nothing
+}
+exports.default = stopPullDownRefresh;

package/cjs/stopPullDownRefresh/index.toutiao.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/cjs/stopPullDownRefresh/index.toutiao.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = tt.stopPullDownRefresh;

package/cjs/stopPullDownRefresh/index.wechat.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/cjs/stopPullDownRefresh/index.wechat.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = wx.stopPullDownRefresh;

package/cjs/utils/capitalize.d.ts

@@ -0,0 +1 @@
+export default function capitalize(str: string): string;

package/cjs/utils/capitalize.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+exports.default = capitalize;

package/cjs/utils/isClassComponent.d.ts

@@ -0,0 +1,2 @@
+import { ComponentClass } from 'react';
+export default function isClassComponent(Component: any): Component is ComponentClass;

package/cjs/utils/isClassComponent.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isClassComponent(Component) {
+    return Component.prototype && typeof Component.prototype.render === 'function';
+}
+exports.default = isClassComponent;

package/cjs/utils/lowercase.d.ts

@@ -0,0 +1 @@
+export default function lowercase(str: string): string;

package/cjs/utils/lowercase.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function lowercase(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+exports.default = lowercase;

package/cjs/utils/plainStyle/CSSProperty.d.ts

@@ -0,0 +1,6 @@
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+export declare const isUnitlessNumber: {
+    [key: string]: boolean;
+};

package/cjs/utils/plainStyle/CSSProperty.js

@@ -0,0 +1,71 @@
+"use strict";
+// https://github.com/facebook/react/blob/master/packages/react-dom/src/shared/CSSProperty.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnitlessNumber = void 0;
+/**
+ * CSS properties which accept numbers but are not in units of "px".
+ */
+exports.isUnitlessNumber = {
+    animationIterationCount: true,
+    borderImageOutset: true,
+    borderImageSlice: true,
+    borderImageWidth: true,
+    boxFlex: true,
+    boxFlexGroup: true,
+    boxOrdinalGroup: true,
+    columnCount: true,
+    columns: true,
+    flex: true,
+    flexGrow: true,
+    flexPositive: true,
+    flexShrink: true,
+    flexNegative: true,
+    flexOrder: true,
+    gridArea: true,
+    gridRow: true,
+    gridRowEnd: true,
+    gridRowSpan: true,
+    gridRowStart: true,
+    gridColumn: true,
+    gridColumnEnd: true,
+    gridColumnSpan: true,
+    gridColumnStart: true,
+    fontWeight: true,
+    lineClamp: true,
+    lineHeight: true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    tabSize: true,
+    widows: true,
+    zIndex: true,
+    zoom: true,
+    // SVG-related properties
+    fillOpacity: true,
+    floodOpacity: true,
+    stopOpacity: true,
+    strokeDasharray: true,
+    strokeDashoffset: true,
+    strokeMiterlimit: true,
+    strokeOpacity: true,
+    strokeWidth: true,
+};
+/**
+ * @param {string} prefix vendor-specific prefix, eg: Webkit
+ * @param {string} key style name, eg: transitionDuration
+ * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
+ * WebkitTransitionDuration
+ */
+function prefixKey(prefix, key) {
+    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
+}
+/**
+ * Support style names that may come passed in prefixed by adding permutations
+ * of vendor prefixes.
+ */
+const prefixes = ['Webkit', 'ms', 'Moz', 'O'];
+for (const prop in exports.isUnitlessNumber) {
+    prefixes.forEach(function (prefix) {
+        exports.isUnitlessNumber[prefixKey(prefix, prop)] = exports.isUnitlessNumber[prop];
+    });
+}

package/cjs/utils/plainStyle/index.d.ts

@@ -0,0 +1,2 @@
+declare const plainStyle: (style: Record<string, string | number>) => string;
+export default plainStyle;

package/cjs/utils/plainStyle/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CSSProperty_1 = require("./CSSProperty");
+const framework_shared_1 = require("@rsmax/framework-shared");
+const vendorPrefixes = ['webkit', 'moz', 'ms', 'o'];
+const transformReactStyleKey = (key) => {
+    // css3 var
+    if (key === null || key === void 0 ? void 0 : key.startsWith('--')) {
+        return key;
+    }
+    let styleValue = key.replace(/\.?([A-Z]+)/g, function (_x, y) {
+        return '-' + y.toLowerCase();
+    });
+    // vendor prefix
+    if (styleValue === null || styleValue === void 0 ? void 0 : styleValue.startsWith('-')) {
+        const firstWord = styleValue.split('-').filter(s => s)[0];
+        styleValue = styleValue.replace(/^-/, '');
+        if ((0, framework_shared_1.find)(vendorPrefixes, prefix => prefix === firstWord)) {
+            styleValue = '-' + styleValue;
+        }
+    }
+    return styleValue;
+};
+const transformPx = (value) => {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    return value.replace(/\b(\d+(\.\d+)?)px\b/g, function (match, x) {
+        const targetUnit = 'rpx';
+        const size = Number(x);
+        return size % 1 === 0 ? size + targetUnit : size.toFixed(2) + targetUnit;
+    });
+};
+const plainStyle = (style) => {
+    return Object.keys(style)
+        .reduce((acc, key) => {
+        let value = style[key];
+        if (!Number.isNaN(Number(value)) && !CSSProperty_1.isUnitlessNumber[key] && !(key === null || key === void 0 ? void 0 : key.startsWith('--'))) {
+            value = value + 'rpx';
+        }
+        return [...acc, `${transformReactStyleKey(key)}:${framework_shared_1.RuntimeOptions.get('pxToRpx') ? transformPx(value) : value};`];
+    }, [])
+        .join('');
+};
+exports.default = plainStyle;

package/esm/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/esm/AppContainer.js

@@ -0,0 +1,34 @@
+import VNode from './VNode';
+import { generate } from './instanceId';
+export default class AppContainer {
+    constructor() {
+        this.updateQueue = [];
+        this.root = new VNode({
+            id: 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);
+    }
+}

package/esm/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/esm/Container.js

@@ -0,0 +1,114 @@
+import VNode from './VNode';
+import { generate } from './instanceId';
+import nativeEffector from './nativeEffect';
+import { RuntimeOptions } from '@rsmax/framework-shared';
+import { unstable_batchedUpdates } from './index';
+export default class Container {
+    constructor(context, rootKey = 'root') {
+        this.updateQueue = [];
+        this.rendered = false;
+        this.context = context;
+        this.root = new VNode({
+            id: 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 = () => {
+                            nativeEffector.run();
+                            /* istanbul ignore next */
+                            if (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, () => {
+            nativeEffector.run();
+            /* istanbul ignore next */
+            if (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 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);
+    }
+}

package/esm/ReactPortal.d.ts

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

package/esm/ReactPortal.js

@@ -0,0 +1,11 @@
+import { Portal } from 'react-is';
+export function createPortal(children, containerInfo, key) {
+    return {
+        // This tag allow us to uniquely identify this as a React Portal
+        $$typeof: Portal,
+        key: key || '',
+        children,
+        containerInfo,
+        implementation: null,
+    };
+}

package/esm/SyntheticEvent/constants.d.ts

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

package/esm/SyntheticEvent/constants.js

@@ -0,0 +1,10 @@
+export const DEPRECATED_CATCH_TYPE = 'catchClick';
+export const SYNTHETIC_TYPES = [
+    'onClick',
+    'onTap',
+    'onLongClick',
+    'onLongTap',
+    'onTouchMove',
+    'onTouchStart',
+    'onTouchEnd',
+];

package/esm/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/esm/SyntheticEvent/createCallbackProxy.js

@@ -0,0 +1,32 @@
+import { find } from '@rsmax/framework-shared';
+import stopPropagation, { validate as validatePropagation, isPropagationStopped } from './stopPropagation';
+import { SYNTHETIC_TYPES, DEPRECATED_CATCH_TYPE } from './constants';
+function isSyntheticType(inputType) {
+    if (DEPRECATED_CATCH_TYPE === inputType) {
+        console.warn('DEPRECATION: remax 已支持在 onClick 事件中使用 stopPropagation 阻止事件冒泡，请尽量不要使用 catchClick');
+    }
+    return !!find(SYNTHETIC_TYPES, type => type === inputType);
+}
+function createBaseSyntheticEvent(node, eventType, nativeEvent) {
+    if (!nativeEvent) {
+        return;
+    }
+    // 添加阻止冒泡方法
+    nativeEvent.stopPropagation = () => {
+        stopPropagation(node, eventType);
+    };
+    return nativeEvent;
+}
+export function createCallbackProxy(eventType, node, callback) {
+    if (!isSyntheticType(eventType)) {
+        return callback;
+    }
+    return function (nativeEvent, ...restParams) {
+        const syntheticEvent = createBaseSyntheticEvent(node, eventType, nativeEvent);
+        if (isPropagationStopped[eventType]) {
+            validatePropagation(node, eventType);
+            return;
+        }
+        return callback(syntheticEvent, ...restParams);
+    };
+}

package/esm/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/esm/SyntheticEvent/stopPropagation.js

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