@blocklet/sdk 1.8.68 → 1.8.69-beta-e0666d0d

package/lib/component/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -25,9 +16,9 @@ const sign = (data) => {
     const signData = typeof data === 'undefined' ? {} : data;
     return { 'x-component-sig': wallet.sign((0, json_stable_stringify_1.default)(signData)) };
 };
-const doCall = ({ url, data }) => __awaiter(void 0, void 0, void 0, function* () {
+const doCall = async ({ url, data }) => {
     try {
-        const resp = yield axios_1.default.post(url, data, { headers: sign(data), timeout: 60000 });
+        const resp = await axios_1.default.post(url, data, { headers: sign(data), timeout: 60000 });
         config_1.logger.info(`call ${url} api success`);
         return resp;
     }
@@ -40,7 +31,7 @@ const doCall = ({ url, data }) => __awaiter(void 0, void 0, void 0, function* ()
         });
         throw new Error(`call ${url} api failed`);
     }
-});
+};
 const parsePorts = () => JSON.parse(process.env.BLOCKLET_WEB_PORTS);
 const getWebEndpoint = (name) => {
     const ports = parsePorts();
@@ -68,11 +59,11 @@ const parseMountPoints = () => {
     });
     return mountPoints;
 };
-const call = ({ name, path: _path, data }) => __awaiter(void 0, void 0, void 0, function* () {
+const call = async ({ name, path: _path, data }) => {
     const baseURL = name ? getChildWebEndpoint(name) : getParentWebEndpoint();
     const url = (0, url_join_1.default)(baseURL, _path);
     return doCall({ url, data });
-});
+};
 exports.call = call;
 const getComponentMountPoint = (keyword) => {
     const mountPoints = parseMountPoints();

package/lib/connect/authenticator.js

@@ -5,11 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const authenticator_1 = require("@did-connect/authenticator");
 const wallet_1 = __importDefault(require("../wallet"));
 const check_blocklet_env_1 = __importDefault(require("../util/check-blocklet-env"));
-const shared_1 = __importDefault(require("./shared"));
+const shared_1 = require("./shared");
 class BlockletAuthenticator extends authenticator_1.Authenticator {
     constructor(options = {}) {
         (0, check_blocklet_env_1.default)();
-        super(Object.assign({ wallet: (0, wallet_1.default)() }, (0, shared_1.default)(options)));
+        super({
+            wallet: (0, wallet_1.default)(),
+            ...(0, shared_1.getAuthenticatorProps)(options),
+        });
     }
 }
 module.exports = BlockletAuthenticator;

package/lib/connect/handler.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -60,8 +51,8 @@ const createConnectHandlers = ({ authenticator, storage, logger = consoleLogger,
         socketPathname,
     });
     const originCreateHandler = handlers.handleSessionCreate;
-    handlers.handleSessionCreate = (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const session = yield originCreateHandler(context);
+    handlers.handleSessionCreate = async (context) => {
+        const session = await originCreateHandler(context);
         const connectedDid = getConnectedDid(session);
         // send notification to wallet to trigger wallet to auto connect
         if (connectedDid) {
@@ -88,12 +79,12 @@ const createConnectHandlers = ({ authenticator, storage, logger = consoleLogger,
             }
             // sendNotificationFn maybe custom function so we need params
             const sendFn = sendNotificationFn || notification_1.sendToUser.bind(notification_1.default);
-            sendFn(connectedDid, message, Object.assign(Object.assign({}, context), { session })).catch((err) => {
+            sendFn(connectedDid, message, { ...context, session }).catch((err) => {
                 console.error(err);
             });
         }
         return session;
-    });
+    };
     return handlers;
 };
 module.exports = createConnectHandlers;

package/lib/connect/shared.d.ts

@@ -1,4 +1,8 @@
-declare const connectShared: (options?: {}) => {
+import { WalletObject } from '@ocap/wallet';
+declare const getDelegator: () => WalletObject<string>;
+declare const getDelegatee: () => WalletObject<string>;
+declare const getDelegation: (delegator: WalletObject, delegatee: WalletObject) => string;
+declare const getAuthenticatorProps: (options?: {}) => {
     appInfo: (...args: any[]) => Promise<{
         name: string | undefined;
         description: string | undefined;
@@ -8,6 +12,8 @@ declare const connectShared: (options?: {}) => {
         subscriptionEndpoint: string;
         nodeDid: string | undefined;
     }>;
+    delegator: () => WalletObject<string>;
+    delegation: () => string;
     chainInfo: () => Record<string, string>;
 };
-export = connectShared;
+export { getDelegation, getDelegator, getDelegatee, getAuthenticatorProps };

package/lib/connect/shared.js

@@ -1,25 +1,81 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthenticatorProps = exports.getDelegatee = exports.getDelegator = exports.getDelegation = void 0;
 const url_join_1 = __importDefault(require("url-join"));
+const wallet_1 = __importDefault(require("@blocklet/meta/lib/wallet"));
+const jwt_1 = require("@arcblock/jwt");
 const util_1 = require("@blocklet/meta/lib/util");
 const constants_1 = require("../util/constants");
 // wraps value in closure or returns closure
 const closure = (value) => (typeof value === 'function' ? value : () => value);
-const connectShared = (options = {}) => (Object.assign(Object.assign({ chainInfo: () => (0, util_1.getChainInfo)(process.env) }, options), { appInfo: (...args) => __awaiter(void 0, void 0, void 0, function* () {
-        const info = yield closure(options.appInfo)(...args);
+const getDelegator = () => {
+    const { BLOCKLET_APP_SK, BLOCKLET_APP_PSK, BLOCKLET_WALLET_TYPE } = process.env;
+    if (BLOCKLET_APP_SK && BLOCKLET_APP_PSK && BLOCKLET_APP_SK !== BLOCKLET_APP_PSK) {
+        return (0, wallet_1.default)(BLOCKLET_APP_PSK, undefined, BLOCKLET_WALLET_TYPE);
+    }
+    return null;
+};
+exports.getDelegator = getDelegator;
+const getDelegatee = () => {
+    const { BLOCKLET_APP_SK, BLOCKLET_WALLET_TYPE } = process.env;
+    return (0, wallet_1.default)(BLOCKLET_APP_SK, undefined, BLOCKLET_WALLET_TYPE);
+};
+exports.getDelegatee = getDelegatee;
+const getDelegation = (delegator, delegatee) => {
+    return (0, jwt_1.signV2)(delegator.address, delegator.secretKey, {
+        agentDid: `did:abt:${delegatee.address}`,
+        permissions: [
+            {
+                role: 'DIDConnectAgent',
+                claims: [
+                    'authPrincipal',
+                    'profile',
+                    'signature',
+                    'prepareTx',
+                    'agreement',
+                    'verifiableCredential',
+                    'asset',
+                    'keyPair',
+                    'encryptionKey',
+                ],
+            },
+        ],
+        exp: Math.floor(new Date().getTime() / 1000) + 60 * 60, // valid for 1 hour
+    });
+};
+exports.getDelegation = getDelegation;
+const getAuthenticatorProps = (options = {}) => ({
+    chainInfo: () => (0, util_1.getChainInfo)(process.env),
+    ...options,
+    appInfo: async (...args) => {
+        const info = await closure(options.appInfo)(...args);
         const { request, baseUrl } = args[0];
         const groupPathPrefix = request.headers['x-group-path-prefix'] || '/';
-        return Object.assign(Object.assign({ name: process.env.BLOCKLET_APP_NAME, description: process.env.BLOCKLET_APP_DESCRIPTION }, (info || {})), { link: (0, util_1.getConnectAppUrl)(args[0]), icon: (0, url_join_1.default)(baseUrl, constants_1.SERVICE_PREFIX, `/blocklet/logo?v=${process.env.BLOCKLET_APP_VERSION || ''}`), updateSubEndpoint: true, subscriptionEndpoint: (0, url_join_1.default)(groupPathPrefix, constants_1.SERVICE_PREFIX, 'websocket'), nodeDid: process.env.ABT_NODE_DID });
-    }) }));
-module.exports = connectShared;
+        return {
+            name: process.env.BLOCKLET_APP_NAME,
+            description: process.env.BLOCKLET_APP_DESCRIPTION,
+            ...(info || {}),
+            link: (0, util_1.getConnectAppUrl)(args[0]),
+            icon: (0, url_join_1.default)(baseUrl, constants_1.SERVICE_PREFIX, `/blocklet/logo?v=${process.env.BLOCKLET_APP_VERSION || ''}`),
+            updateSubEndpoint: true,
+            subscriptionEndpoint: (0, url_join_1.default)(groupPathPrefix, constants_1.SERVICE_PREFIX, 'websocket'),
+            nodeDid: process.env.ABT_NODE_DID,
+        };
+    },
+    delegator: () => {
+        const delegator = getDelegator();
+        return delegator;
+    },
+    delegation: () => {
+        const delegator = getDelegator();
+        if (delegator) {
+            const delegatee = getDelegatee();
+            return getDelegation(delegator, delegatee);
+        }
+        return null;
+    },
+});
+exports.getAuthenticatorProps = getAuthenticatorProps;

package/lib/database/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -28,27 +19,29 @@ class DataBase extends core_1.DataStore {
         const DB_DIR = path_1.default.join(process.env.BLOCKLET_DATA_DIR, 'db');
         fs_extra_1.default.ensureDirSync(DB_DIR);
         const filename = options.filename || path_1.default.join(DB_DIR, `${name}.db`);
-        super(Object.assign({ filename, autoload: true, timestampData: true, onload: (err) => {
+        super({
+            filename,
+            autoload: true,
+            timestampData: true,
+            onload: (err) => {
                 if (err) {
                     console.error(`failed to load disk database ${filename}`, err);
                 }
-            } }, options));
-    }
-    exists(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const doc = yield this.findOne(...args);
-            return !!doc;
+            },
+            ...options,
         });
     }
-    paginate({ condition = {}, sort = {}, page = 1, size = 100, projection = {} }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cursor(condition)
-                .sort(sort)
-                .skip(Math.max(page * size - size, 0))
-                .limit(Math.max(size, 1))
-                .projection(projection)
-                .exec();
-        });
+    async exists(...args) {
+        const doc = await this.findOne(...args);
+        return !!doc;
+    }
+    async paginate({ condition = {}, sort = {}, page = 1, size = 100, projection = {} }) {
+        return this.cursor(condition)
+            .sort(sort)
+            .skip(Math.max(page * size - size, 0))
+            .limit(Math.max(size, 1))
+            .projection(projection)
+            .exec();
     }
 }
 module.exports = DataBase;

package/lib/embed/adapters/express.d.ts

@@ -0,0 +1,3 @@
+import type { Request, Response } from 'express';
+declare function expressEmbed(req: Request, res: Response): Promise<void>;
+export default expressEmbed;

package/lib/embed/adapters/express.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_embed_1 = __importDefault(require("../get-embed"));
+async function expressEmbed(req, res) {
+    const { query = {} } = req;
+    const { url = '' } = query;
+    const data = await (0, get_embed_1.default)(url);
+    res.json(data);
+}
+exports.default = expressEmbed;

package/lib/embed/generate.d.ts

@@ -0,0 +1,6 @@
+export default function generateBlockletEmbed(): {
+    name: string;
+    url: string;
+    origin: string;
+    embed: any[];
+};

package/lib/embed/generate.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function safeJsonParse(input, defaultValue) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return defaultValue;
+    }
+}
+function generateBlockletEmbed() {
+    const { BLOCKLET_APP_NAME, BLOCKLET_APP_URL, BLOCKLET_REAL_NAME } = process.env;
+    const BLOCKLET_MOUNT_POINTS = safeJsonParse(process.env.BLOCKLET_MOUNT_POINTS, []);
+    let url = '/';
+    let name = BLOCKLET_APP_NAME;
+    const blockletNames = BLOCKLET_REAL_NAME.split('/');
+    const componentBlocklet = BLOCKLET_MOUNT_POINTS.find((blockletItem) => blockletItem.name === blockletNames[blockletNames.length - 1]);
+    if (componentBlocklet) {
+        // 先假设只有一层 component blocklet
+        url = componentBlocklet.mountPoint;
+        name = componentBlocklet.title;
+    }
+    return {
+        name,
+        url,
+        origin: BLOCKLET_APP_URL,
+        embed: [],
+    };
+}
+exports.default = generateBlockletEmbed;

package/lib/embed/get-embed-url.d.ts

@@ -0,0 +1 @@
+export default function getEmbedUrlFromUrl(url: string): Promise<string>;

package/lib/embed/get-embed-url.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slim_1 = require("cheerio/lib/slim");
+const ufo_1 = require("ufo");
+const axios_1 = __importDefault(require("axios"));
+/**
+ * 判断 htmlContent 是否为开发环境
+ * @param {string} htmlContent
+ * @returns boolean
+ */
+function checkViteDev(htmlContent) {
+    const $ = (0, slim_1.load)(htmlContent);
+    const scirptList = $('script[type="module"]');
+    return !![...scirptList].find((scriptItem) => {
+        if (scriptItem.firstChild?.type === 'text') {
+            return scriptItem.firstChild?.data?.includes('window.__vite_plugin_react_preamble_installed__ = true');
+        }
+        return false;
+    });
+}
+async function getEmbedUrlFromUrl(url) {
+    try {
+        const { data: htmlContent } = await axios_1.default.get(url, {
+            headers: {
+                accept: 'text/html,application/xhtml+xml,application/xml',
+            },
+        });
+        let prefix = '/';
+        let metaUrl = url;
+        const $ = (0, slim_1.load)(htmlContent);
+        const link = $('link[rel="blocklet-open-embed"]');
+        const blockletScript = $('script[src="__blocklet__.js"]');
+        if (link && link.length > 0) {
+            metaUrl = link.attr('href') || url;
+        }
+        else {
+            return url;
+        }
+        const isViteDev = checkViteDev(htmlContent);
+        if (blockletScript && blockletScript.length > 0) {
+            const scriptUrl = new URL('__blocklet__.js?type=json', (0, ufo_1.withTrailingSlash)(url));
+            const { data: blockletMeta } = await axios_1.default.get(scriptUrl.href);
+            prefix = blockletMeta.prefix;
+        }
+        // 在 vite 开发模式下，embed-url 指向的地址会自动被增加一个前缀
+        return isViteDev ? (0, ufo_1.joinURL)(prefix, metaUrl.replace(prefix, '')) : (0, ufo_1.joinURL)(prefix, metaUrl);
+    }
+    catch {
+        return url;
+    }
+}
+exports.default = getEmbedUrlFromUrl;

package/lib/embed/get-embed.d.ts

@@ -0,0 +1 @@
+export default function getBlockletEmbedFromUrl(url: string): Promise<object | null>;

package/lib/embed/get-embed.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const lodash_1 = require("lodash");
+const axios_1 = __importDefault(require("axios"));
+const get_embed_url_1 = __importDefault(require("./get-embed-url"));
+async function getBlockletEmbedFromUrl(url) {
+    const metaUrl = await (0, get_embed_url_1.default)(url);
+    try {
+        if (metaUrl) {
+            let finalUrl = '';
+            if (metaUrl.startsWith('http://') || metaUrl.startsWith('https://')) {
+                finalUrl = metaUrl;
+            }
+            else {
+                finalUrl = `${new URL(url).origin}${(0, path_1.join)('/', metaUrl)}`;
+            }
+            const { data: metaData } = await axios_1.default.get(finalUrl);
+            if ((0, lodash_1.isObject)(metaData)) {
+                return metaData;
+            }
+        }
+    }
+    catch {
+        /* empty */
+    }
+    return null;
+}
+exports.default = getBlockletEmbedFromUrl;

package/lib/embed/index.d.ts

@@ -0,0 +1,10 @@
+import generateBlockletEmbed from './generate';
+import expressEmbed from './adapters/express';
+import getBlockletEmbedFromUrl from './get-embed';
+declare const _default: {
+    expressEmbed: typeof expressEmbed;
+    generateBlockletEmbed: typeof generateBlockletEmbed;
+    getBlockletEmbedFromUrl: typeof getBlockletEmbedFromUrl;
+};
+export default _default;
+export { expressEmbed, generateBlockletEmbed, getBlockletEmbedFromUrl };

package/lib/embed/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockletEmbedFromUrl = exports.generateBlockletEmbed = exports.expressEmbed = void 0;
+const generate_1 = __importDefault(require("./generate"));
+exports.generateBlockletEmbed = generate_1.default;
+const express_1 = __importDefault(require("./adapters/express"));
+exports.expressEmbed = express_1.default;
+const get_embed_1 = __importDefault(require("./get-embed"));
+exports.getBlockletEmbedFromUrl = get_embed_1.default;
+exports.default = { expressEmbed: express_1.default, generateBlockletEmbed: generate_1.default, getBlockletEmbedFromUrl: get_embed_1.default };

package/lib/embed/message.d.ts

@@ -0,0 +1,26 @@
+type InstanceType = 'client' | 'server';
+type MessageType = string;
+interface Callback {
+    (...args: any[]): void;
+}
+declare class Message {
+    id: string;
+    type: InstanceType;
+    private bc;
+    private eventMap;
+    init: (cb: Callback) => void;
+    onInit: (getData: () => any) => void;
+    close: () => void;
+    constructor(id: string, type?: InstanceType);
+    on(type: MessageType, cb: Callback): void;
+    off(type: MessageType, cb: Callback): void;
+    once(type: MessageType, cb: Callback): void;
+    send(type: MessageType, payload: any): void;
+}
+declare function useMessage(id?: string, type?: InstanceType): any;
+declare const _default: {
+    useMessage: typeof useMessage;
+    Message: typeof Message;
+};
+export default _default;
+export { useMessage, Message };

package/lib/embed/message.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.useMessage = void 0;
+const INIT = '__init';
+const ON_INIT = '__on-init';
+function checkKey(typeKey) {
+    return !typeKey.startsWith(INIT);
+}
+function ensureType(type) {
+    if (!checkKey(type)) {
+        throw new Error(`Type can't starts with ${INIT}`);
+    }
+}
+function notExist() {
+    console.error('function not exist');
+}
+class Message {
+    constructor(id, type = 'client') {
+        this.id = id;
+        this.type = type;
+        const bc = new BroadcastChannel(this.id);
+        this.bc = bc;
+        this.eventMap = new Map();
+        const onMessage = (event) => {
+            const { data } = event;
+            const { type: messageType, payload, id: dataId } = data;
+            if (dataId === this.id) {
+                const cbList = this.eventMap.get(messageType) || [];
+                cbList.forEach((cbItem) => {
+                    cbItem(payload);
+                });
+            }
+        };
+        window.addEventListener('message', onMessage, false);
+        this.close = () => {
+            window.removeEventListener('message', onMessage, false);
+            // v1 message
+            this.bc.close();
+        };
+        // v1 message
+        bc.onmessage = ({ data }) => {
+            const { type: messageType, payload } = data;
+            const cbList = this.eventMap.get(messageType) || [];
+            cbList.forEach((cbItem) => {
+                cbItem(payload);
+            });
+        };
+        this.init = notExist;
+        this.onInit = notExist;
+        if (type === 'server') {
+            this.onInit = (getData = () => null) => {
+                this.eventMap.set(INIT, [
+                    (listenKey) => {
+                        const initData = getData();
+                        this.send(listenKey, initData);
+                    },
+                ]);
+            };
+        }
+        if (type === 'client') {
+            this.init = (cb) => {
+                const uniqueId = String(+new Date());
+                const listenKey = `${ON_INIT}_${uniqueId}`;
+                this.once(listenKey, cb);
+                this.send(INIT, listenKey);
+            };
+        }
+    }
+    on(type, cb) {
+        ensureType(type);
+        const cbList = this.eventMap.get(type) || [];
+        cbList.push(cb);
+        this.eventMap.set(type, cbList);
+    }
+    off(type, cb) {
+        ensureType(type);
+        const cbList = this.eventMap.get(type) || [];
+        if (cb) {
+            const index = cbList.indexOf(cb);
+            if (index !== -1) {
+                cbList.splice(index, 1);
+            }
+        }
+        else {
+            cbList.length = 0;
+        }
+        this.eventMap.set(type, cbList);
+    }
+    once(type, cb) {
+        ensureType(type);
+        const callback = (...args) => {
+            cb(...args);
+            this.off(type, callback);
+        };
+        this.on(type, callback);
+    }
+    send(type, payload) {
+        const data = {
+            id: this.id,
+            type,
+            payload,
+        };
+        if (this.type === 'server') {
+            const iframeList = [...document.querySelectorAll(`iframe[data-id="${this.id}"]`)];
+            iframeList.forEach((iframeItem) => {
+                iframeItem.contentWindow.postMessage(data, '*');
+            });
+        }
+        else {
+            window.parent.postMessage(data, '*');
+        }
+        // v1 message
+        this.bc.postMessage(data);
+    }
+}
+exports.Message = Message;
+const messageCache = new Map();
+function useMessage(id, type = 'client') {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const _id = id || window.frameElement?.dataset.id || window.name;
+    if (messageCache.has(_id)) {
+        return messageCache.get(_id);
+    }
+    const isInIframe = window !== window.parent;
+    const message = (type === 'server' || isInIframe) && _id ? new Message(_id, type) : null;
+    const data = { message };
+    messageCache.set(_id, data);
+    return data;
+}
+exports.useMessage = useMessage;
+exports.default = {
+    useMessage,
+    Message,
+};

package/lib/env.d.ts

@@ -1,5 +1,6 @@
 declare const _default: Readonly<{
     appId: string;
+    appPid: string;
     appName: string;
     appDescription: string;
     appUrl: string;