@heybox/hb-sdk 0.8.3-alpha.5 → 0.8.3-alpha.9

package/dist/devtools/browser-dev-host/index.html

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="theme-color" content="#f4f5f7" />
     <title>小程序工坊调试台</title>
-    <script type="module" crossorigin src="/assets/index-8N4og21f.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/desktop-app-launch-BbRQb08Y.js">
+    <script type="module" crossorigin src="/assets/index-BUsHRfad.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/desktop-app-launch-C0HMYsbA.js">
     <link rel="stylesheet" crossorigin href="/assets/index-BrXEMo2-.css">
   </head>
   <body>

package/dist/index.cjs.js

@@ -1342,7 +1342,7 @@ function createMessageId() {
 /** 构建时替换为当前发布包的实际版本。 */
 const HB_SDK_VERSION = typeof undefined === 'string'
     ? undefined
-    : '0.8.3-alpha.5';
+    : '0.8.3-alpha.9';
 
 const RUNTIME_MODES = new Set(['production', 'preview', 'development', 'unknown']);
 const OPERATING_SYSTEM_NAMES = new Set(['android', 'ios', 'ohos', 'windows', 'macos', 'linux', 'unknown']);
@@ -2594,6 +2594,14 @@ function copyLink(requester, options) {
 
 // Integer Utility
 var UINT32_MAX = 4294967295;
+// DataView extension to handle int64 / uint64,
+// where the actual range is 53-bits integer (a.k.a. safe integer)
+function setUint64(view, offset, value) {
+    var high = value / 4294967296;
+    var low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
 function setInt64(view, offset, value) {
     var high = Math.floor(value / 4294967296);
     var low = value; // high bits are truncated by DataView
@@ -2615,8 +2623,89 @@ var _a, _b, _c;
 var TEXT_ENCODING_AVAILABLE = (typeof process === "undefined" || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a["TEXT_ENCODING"]) !== "never") &&
     typeof TextEncoder !== "undefined" &&
     typeof TextDecoder !== "undefined";
+function utf8Count(str) {
+    var strLength = str.length;
+    var byteLength = 0;
+    var pos = 0;
+    while (pos < strLength) {
+        var value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            byteLength++;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            byteLength += 2;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    var extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                byteLength += 3;
+            }
+            else {
+                // 4-byte
+                byteLength += 4;
+            }
+        }
+    }
+    return byteLength;
+}
+function utf8EncodeJs(str, output, outputOffset) {
+    var strLength = str.length;
+    var offset = outputOffset;
+    var pos = 0;
+    while (pos < strLength) {
+        var value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            output[offset++] = value;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            output[offset++] = ((value >> 6) & 0x1f) | 0xc0;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    var extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                output[offset++] = ((value >> 12) & 0x0f) | 0xe0;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+            else {
+                // 4-byte
+                output[offset++] = ((value >> 18) & 0x07) | 0xf0;
+                output[offset++] = ((value >> 12) & 0x3f) | 0x80;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+        }
+        output[offset++] = (value & 0x3f) | 0x80;
+    }
+}
 var sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;
-!TEXT_ENCODING_AVAILABLE
+var TEXT_ENCODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
     ? UINT32_MAX
     : typeof process !== "undefined" && ((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b["TEXT_ENCODING"]) !== "force"
         ? 200
@@ -2627,7 +2716,7 @@ function utf8EncodeTEencode(str, output, outputOffset) {
 function utf8EncodeTEencodeInto(str, output, outputOffset) {
     sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
 }
-(sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
+var utf8EncodeTE = (sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
 var CHUNK_SIZE = 4096;
 function utf8DecodeJs(bytes, inputOffset, byteLength) {
     var offset = inputOffset;
@@ -2917,6 +3006,431 @@ function createDataView(buffer) {
     return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);
 }
 
+var DEFAULT_MAX_DEPTH = 100;
+var DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+var Encoder = /** @class */ (function () {
+    function Encoder(extensionCodec, context, maxDepth, initialBufferSize, sortKeys, forceFloat32, ignoreUndefined, forceIntegerToFloat) {
+        if (extensionCodec === void 0) { extensionCodec = ExtensionCodec.defaultCodec; }
+        if (context === void 0) { context = undefined; }
+        if (maxDepth === void 0) { maxDepth = DEFAULT_MAX_DEPTH; }
+        if (initialBufferSize === void 0) { initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE; }
+        if (sortKeys === void 0) { sortKeys = false; }
+        if (forceFloat32 === void 0) { forceFloat32 = false; }
+        if (ignoreUndefined === void 0) { ignoreUndefined = false; }
+        if (forceIntegerToFloat === void 0) { forceIntegerToFloat = false; }
+        this.extensionCodec = extensionCodec;
+        this.context = context;
+        this.maxDepth = maxDepth;
+        this.initialBufferSize = initialBufferSize;
+        this.sortKeys = sortKeys;
+        this.forceFloat32 = forceFloat32;
+        this.ignoreUndefined = ignoreUndefined;
+        this.forceIntegerToFloat = forceIntegerToFloat;
+        this.pos = 0;
+        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+        this.bytes = new Uint8Array(this.view.buffer);
+    }
+    Encoder.prototype.reinitializeState = function () {
+        this.pos = 0;
+    };
+    /**
+     * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+     *
+     * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+     */
+    Encoder.prototype.encodeSharedRef = function (object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.subarray(0, this.pos);
+    };
+    /**
+     * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+     */
+    Encoder.prototype.encode = function (object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.slice(0, this.pos);
+    };
+    Encoder.prototype.doEncode = function (object, depth) {
+        if (depth > this.maxDepth) {
+            throw new Error("Too deep objects in depth ".concat(depth));
+        }
+        if (object == null) {
+            this.encodeNil();
+        }
+        else if (typeof object === "boolean") {
+            this.encodeBoolean(object);
+        }
+        else if (typeof object === "number") {
+            this.encodeNumber(object);
+        }
+        else if (typeof object === "string") {
+            this.encodeString(object);
+        }
+        else {
+            this.encodeObject(object, depth);
+        }
+    };
+    Encoder.prototype.ensureBufferSizeToWrite = function (sizeToWrite) {
+        var requiredSize = this.pos + sizeToWrite;
+        if (this.view.byteLength < requiredSize) {
+            this.resizeBuffer(requiredSize * 2);
+        }
+    };
+    Encoder.prototype.resizeBuffer = function (newSize) {
+        var newBuffer = new ArrayBuffer(newSize);
+        var newBytes = new Uint8Array(newBuffer);
+        var newView = new DataView(newBuffer);
+        newBytes.set(this.bytes);
+        this.view = newView;
+        this.bytes = newBytes;
+    };
+    Encoder.prototype.encodeNil = function () {
+        this.writeU8(0xc0);
+    };
+    Encoder.prototype.encodeBoolean = function (object) {
+        if (object === false) {
+            this.writeU8(0xc2);
+        }
+        else {
+            this.writeU8(0xc3);
+        }
+    };
+    Encoder.prototype.encodeNumber = function (object) {
+        if (Number.isSafeInteger(object) && !this.forceIntegerToFloat) {
+            if (object >= 0) {
+                if (object < 0x80) {
+                    // positive fixint
+                    this.writeU8(object);
+                }
+                else if (object < 0x100) {
+                    // uint 8
+                    this.writeU8(0xcc);
+                    this.writeU8(object);
+                }
+                else if (object < 0x10000) {
+                    // uint 16
+                    this.writeU8(0xcd);
+                    this.writeU16(object);
+                }
+                else if (object < 0x100000000) {
+                    // uint 32
+                    this.writeU8(0xce);
+                    this.writeU32(object);
+                }
+                else {
+                    // uint 64
+                    this.writeU8(0xcf);
+                    this.writeU64(object);
+                }
+            }
+            else {
+                if (object >= -32) {
+                    // negative fixint
+                    this.writeU8(0xe0 | (object + 0x20));
+                }
+                else if (object >= -128) {
+                    // int 8
+                    this.writeU8(0xd0);
+                    this.writeI8(object);
+                }
+                else if (object >= -32768) {
+                    // int 16
+                    this.writeU8(0xd1);
+                    this.writeI16(object);
+                }
+                else if (object >= -2147483648) {
+                    // int 32
+                    this.writeU8(0xd2);
+                    this.writeI32(object);
+                }
+                else {
+                    // int 64
+                    this.writeU8(0xd3);
+                    this.writeI64(object);
+                }
+            }
+        }
+        else {
+            // non-integer numbers
+            if (this.forceFloat32) {
+                // float 32
+                this.writeU8(0xca);
+                this.writeF32(object);
+            }
+            else {
+                // float 64
+                this.writeU8(0xcb);
+                this.writeF64(object);
+            }
+        }
+    };
+    Encoder.prototype.writeStringHeader = function (byteLength) {
+        if (byteLength < 32) {
+            // fixstr
+            this.writeU8(0xa0 + byteLength);
+        }
+        else if (byteLength < 0x100) {
+            // str 8
+            this.writeU8(0xd9);
+            this.writeU8(byteLength);
+        }
+        else if (byteLength < 0x10000) {
+            // str 16
+            this.writeU8(0xda);
+            this.writeU16(byteLength);
+        }
+        else if (byteLength < 0x100000000) {
+            // str 32
+            this.writeU8(0xdb);
+            this.writeU32(byteLength);
+        }
+        else {
+            throw new Error("Too long string: ".concat(byteLength, " bytes in UTF-8"));
+        }
+    };
+    Encoder.prototype.encodeString = function (object) {
+        var maxHeaderSize = 1 + 4;
+        var strLength = object.length;
+        if (strLength > TEXT_ENCODER_THRESHOLD) {
+            var byteLength = utf8Count(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            utf8EncodeTE(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+        else {
+            var byteLength = utf8Count(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            utf8EncodeJs(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+    };
+    Encoder.prototype.encodeObject = function (object, depth) {
+        // try to encode objects with custom codec first of non-primitives
+        var ext = this.extensionCodec.tryToEncode(object, this.context);
+        if (ext != null) {
+            this.encodeExtension(ext);
+        }
+        else if (Array.isArray(object)) {
+            this.encodeArray(object, depth);
+        }
+        else if (ArrayBuffer.isView(object)) {
+            this.encodeBinary(object);
+        }
+        else if (typeof object === "object") {
+            this.encodeMap(object, depth);
+        }
+        else {
+            // symbol, function and other special object come here unless extensionCodec handles them.
+            throw new Error("Unrecognized object: ".concat(Object.prototype.toString.apply(object)));
+        }
+    };
+    Encoder.prototype.encodeBinary = function (object) {
+        var size = object.byteLength;
+        if (size < 0x100) {
+            // bin 8
+            this.writeU8(0xc4);
+            this.writeU8(size);
+        }
+        else if (size < 0x10000) {
+            // bin 16
+            this.writeU8(0xc5);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // bin 32
+            this.writeU8(0xc6);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large binary: ".concat(size));
+        }
+        var bytes = ensureUint8Array(object);
+        this.writeU8a(bytes);
+    };
+    Encoder.prototype.encodeArray = function (object, depth) {
+        var size = object.length;
+        if (size < 16) {
+            // fixarray
+            this.writeU8(0x90 + size);
+        }
+        else if (size < 0x10000) {
+            // array 16
+            this.writeU8(0xdc);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // array 32
+            this.writeU8(0xdd);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large array: ".concat(size));
+        }
+        for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {
+            var item = object_1[_i];
+            this.doEncode(item, depth + 1);
+        }
+    };
+    Encoder.prototype.countWithoutUndefined = function (object, keys) {
+        var count = 0;
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            if (object[key] !== undefined) {
+                count++;
+            }
+        }
+        return count;
+    };
+    Encoder.prototype.encodeMap = function (object, depth) {
+        var keys = Object.keys(object);
+        if (this.sortKeys) {
+            keys.sort();
+        }
+        var size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+        if (size < 16) {
+            // fixmap
+            this.writeU8(0x80 + size);
+        }
+        else if (size < 0x10000) {
+            // map 16
+            this.writeU8(0xde);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // map 32
+            this.writeU8(0xdf);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large map object: ".concat(size));
+        }
+        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
+            var key = keys_2[_i];
+            var value = object[key];
+            if (!(this.ignoreUndefined && value === undefined)) {
+                this.encodeString(key);
+                this.doEncode(value, depth + 1);
+            }
+        }
+    };
+    Encoder.prototype.encodeExtension = function (ext) {
+        var size = ext.data.length;
+        if (size === 1) {
+            // fixext 1
+            this.writeU8(0xd4);
+        }
+        else if (size === 2) {
+            // fixext 2
+            this.writeU8(0xd5);
+        }
+        else if (size === 4) {
+            // fixext 4
+            this.writeU8(0xd6);
+        }
+        else if (size === 8) {
+            // fixext 8
+            this.writeU8(0xd7);
+        }
+        else if (size === 16) {
+            // fixext 16
+            this.writeU8(0xd8);
+        }
+        else if (size < 0x100) {
+            // ext 8
+            this.writeU8(0xc7);
+            this.writeU8(size);
+        }
+        else if (size < 0x10000) {
+            // ext 16
+            this.writeU8(0xc8);
+            this.writeU16(size);
+        }
+        else if (size < 0x100000000) {
+            // ext 32
+            this.writeU8(0xc9);
+            this.writeU32(size);
+        }
+        else {
+            throw new Error("Too large extension object: ".concat(size));
+        }
+        this.writeI8(ext.type);
+        this.writeU8a(ext.data);
+    };
+    Encoder.prototype.writeU8 = function (value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setUint8(this.pos, value);
+        this.pos++;
+    };
+    Encoder.prototype.writeU8a = function (values) {
+        var size = values.length;
+        this.ensureBufferSizeToWrite(size);
+        this.bytes.set(values, this.pos);
+        this.pos += size;
+    };
+    Encoder.prototype.writeI8 = function (value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setInt8(this.pos, value);
+        this.pos++;
+    };
+    Encoder.prototype.writeU16 = function (value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setUint16(this.pos, value);
+        this.pos += 2;
+    };
+    Encoder.prototype.writeI16 = function (value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setInt16(this.pos, value);
+        this.pos += 2;
+    };
+    Encoder.prototype.writeU32 = function (value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setUint32(this.pos, value);
+        this.pos += 4;
+    };
+    Encoder.prototype.writeI32 = function (value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setInt32(this.pos, value);
+        this.pos += 4;
+    };
+    Encoder.prototype.writeF32 = function (value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setFloat32(this.pos, value);
+        this.pos += 4;
+    };
+    Encoder.prototype.writeF64 = function (value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setFloat64(this.pos, value);
+        this.pos += 8;
+    };
+    Encoder.prototype.writeU64 = function (value) {
+        this.ensureBufferSizeToWrite(8);
+        setUint64(this.view, this.pos, value);
+        this.pos += 8;
+    };
+    Encoder.prototype.writeI64 = function (value) {
+        this.ensureBufferSizeToWrite(8);
+        setInt64(this.view, this.pos, value);
+        this.pos += 8;
+    };
+    return Encoder;
+}());
+
+var defaultEncodeOptions = {};
+/**
+ * It encodes `value` in the MessagePack format and
+ * returns a byte buffer.
+ *
+ * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.
+ */
+function encode(value, options) {
+    if (options === void 0) { options = defaultEncodeOptions; }
+    var encoder = new Encoder(options.extensionCodec, options.context, options.maxDepth, options.initialBufferSize, options.sortKeys, options.forceFloat32, options.ignoreUndefined, options.forceIntegerToFloat);
+    return encoder.encodeSharedRef(value);
+}
+
 function prettyByte(byte) {
     return "".concat(byte < 0 ? "-" : "", "0x").concat(Math.abs(byte).toString(16).padStart(2, "0"));
 }
@@ -3724,6 +4238,13 @@ function decode(buffer, options) {
     return decoder.decode(buffer);
 }
 
+/** 校验公开启动扩展数据，并保持调用方传入的值语义不变。 */
+function normalizeMiniProgramShareExtra(value) {
+    assertExtraValue(value);
+    if (encode(value).byteLength > 128)
+        throw new Error('extra is too large');
+    return value;
+}
 /** 读取小程序启动时携带的分享数据。 */
 function readMiniProgramShareExtra(launchHref) {
     if (!launchHref)
@@ -3770,11 +4291,14 @@ function assertExtraValue(value, depth = 0, seen = new WeakSet()) {
     const prototype = Object.getPrototypeOf(value);
     if (prototype !== Object.prototype && prototype !== null)
         throw new Error('extra object must be a plain object');
-    const values = Object.values(value);
-    if (values.length > 64)
+    const entries = Object.entries(value);
+    if (entries.length > 64)
         throw new Error('extra object has too many fields');
-    for (const item of values)
+    for (const [key, item] of entries) {
+        if (key === '__proto__')
+            throw new Error('extra object key is not supported');
         assertExtraValue(item, depth + 1, seen);
+    }
     seen.delete(value);
 }
 function decodeBase64Url(value) {
@@ -4568,10 +5092,27 @@ function normalizeOpenAppPageOptions(options) {
             return normalizeUserDetailOptions(options);
         case 'post_detail':
             return normalizePostDetailOptions(options);
+        case 'mini_program':
+            return normalizeMiniProgramOptions(options);
         default:
             throw createSDKError('INVALID_PARAMS', 'navigation.openAppPage target 不支持');
     }
 }
+function normalizeMiniProgramOptions(options) {
+    const payload = {
+        target: 'mini_program',
+        miniProgramId: readRequiredString(options.miniProgramId, 'navigation.openAppPage miniProgramId 必须是非空字符串'),
+    };
+    if (options.extra !== undefined) {
+        try {
+            payload.extra = normalizeMiniProgramShareExtra(options.extra);
+        }
+        catch {
+            throw createSDKError('INVALID_PARAMS', 'navigation.openAppPage extra 必须是符合限制的 JSON-compatible 数据');
+        }
+    }
+    return payload;
+}
 function normalizeGameDetailOptions(options) {
     const appId = readRequiredStringLike(options.appId, 'navigation.openAppPage appId 必须是非空字符串或数字');
     if (!GAME_DETAIL_GAME_TYPES.has(options.gameType)) {
@@ -4664,14 +5205,14 @@ function reload(requester) {
     return requester.request(NAVIGATION_RELOAD_METHOD);
 }
 /**
- * 请求宿主打开受 SDK 白名单约束的黑盒 App 页面。
+ * 请求宿主打开受 SDK 白名单约束的黑盒 App 页面或公开小程序。
  *
  * @param requester - 底层 bridge 请求能力。
  * @param options - 由 `target` 判别的目标页参数；发送前会校验并规范化。
  * @returns Host 发起受控页面路由后 resolve `undefined`。
  * @throws {@link HbMiniProgramSDKError} 参数非法、目标不受 Host 支持、路由失败或 SDK /
  * Runtime 已终止时抛出。
- * @remarks 该能力不接受任意 URL 或内部路由，也无需 Manifest 权限或可信用户手势。
+ * @remarks 该能力不接受任意 URL、版本或内部路由，也无需 Manifest 权限或可信用户手势。
  * @see [navigation.openAppPage](/reference/sdk/navigation/openAppPage)
  */
 function openAppPage(requester, options) {