@blocklet/meta 1.15.17 → 1.16.0-beta-8ee536d7

package/lib/index.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import constants from './constants';
+import parse from './parse';
+import toBlockletDid from './did';
+import getBlockletWallet from './wallet';
+import getBlockletInfo from './info';
+import getBlockletEngine from './engine';
+import { validateMeta, fixAndValidateService } from './validate';
+import { formatPerson, parsePerson, fixPerson, fixInterfaces, fixService, fixName } from './fix';
+import { list, select, update, read } from './file';
+import verifyMultiSig from './verify-multi-sig';
+export { constants };
+export { list };
+export { select };
+export { update };
+export { read };
+export { parse };
+export { validateMeta };
+export { fixAndValidateService };
+export { formatPerson };
+export { parsePerson };
+export { fixPerson };
+export { fixInterfaces };
+export { fixService };
+export { fixName };
+export { toBlockletDid };
+export { getBlockletWallet };
+export { getBlockletInfo };
+export { getBlockletEngine };
+export { verifyMultiSig };
+declare const _default: {
+    constants: any;
+    list: any[];
+    select: (dir: string, { throwOnError }?: {
+        throwOnError?: boolean;
+    }) => string;
+    update: (file: string, meta: import("./types").TBlockletMeta, { fix }?: {
+        fix?: boolean;
+    }) => void;
+    read: (file: string) => unknown;
+    parse: (dir: string, { ensureMain, ensureFiles, ensureDist, ensureComponentStore, extraRawAttrs, schemaOptions, defaultStoreUrl, fix, }?: {
+        ensureMain?: boolean;
+        ensureFiles?: boolean;
+        ensureDist?: boolean;
+        ensureComponentStore?: boolean;
+        extraRawAttrs?: any;
+        schemaOptions?: any;
+        enableDefaults?: boolean;
+        extraAttrSpec?: any;
+        defaultStoreUrl?: string | ((component: import("./types").TComponent) => string);
+        fix?: boolean;
+    }) => import("./types").TBlockletMeta;
+    validateMeta: (meta: any, { ensureMain, ensureFiles, ensureDist, ensureComponentStore, ensureName, skipValidateDidName, schemaOptions, }?: {
+        ensureMain?: boolean;
+        ensureFiles?: boolean;
+        ensureDist?: boolean;
+        ensureComponentStore?: boolean;
+        ensureName?: boolean;
+        skipValidateDidName?: boolean;
+        schemaOptions?: any;
+    }) => import("./types").TBlockletMeta;
+    fixAndValidateService: (meta: import("./types").TBlockletMeta) => import("./types").TBlockletMeta;
+    formatPerson: (person: string | Record<string, any>) => string;
+    parsePerson: (person: string) => any;
+    fixPerson: (data: any) => any;
+    fixInterfaces: (meta: any, removeMerged?: boolean) => any;
+    fixName: (meta: any) => any;
+    fixService: (meta: import("./types").TBlockletMeta) => import("./types").TBlockletMeta;
+    toBlockletDid: (name: string | Buffer) => string;
+    getBlockletWallet: (blockletDid: string, nodeSk?: string, type?: string | import("@arcblock/did").DIDType, index?: number) => import("@ocap/wallet").WalletObject<string>;
+    getBlockletInfo: (state: import("@abtnode/client").BlockletState, nodeSk?: string, { returnWallet }?: {
+        returnWallet?: boolean;
+    }) => {
+        did: string;
+        name: string;
+        version: string;
+        description: string;
+        passportColor: string;
+        appUrl: string;
+        wallet: import("@ocap/wallet").WalletObject<string>;
+        permanentWallet: import("@ocap/wallet").WalletObject<string>;
+    };
+    getBlockletEngine: (meta: import("./types").TBlockletMeta) => import("./types").TEngine;
+    verifyMultiSig: (blockletMeta: import("./types").TBlockletMeta) => boolean;
+};
+export default _default;

package/lib/index.js

@@ -1,35 +1,56 @@
-const constants = require('./constants');
-const parse = require('./parse');
-const toBlockletDid = require('./did');
-const getBlockletWallet = require('./wallet');
-const getBlockletInfo = require('./info');
-const getBlockletEngine = require('./engine');
-const { validateMeta, fixAndValidateService } = require('./validate');
-const { formatPerson, parsePerson, fixPerson, fixInterfaces, fixService } = require('./fix');
-const { list, select, update } = require('./file');
-const verifyMultiSig = require('./verify-multi-sig');
-
-module.exports = {
-  constants,
-
-  list,
-  select,
-  update,
-
-  parse,
-  validateMeta,
-  fixAndValidateService,
-
-  formatPerson,
-  parsePerson,
-  fixPerson,
-  fixInterfaces,
-  fixService,
-
-  toBlockletDid,
-  getBlockletWallet,
-  getBlockletInfo,
-  getBlockletEngine,
-
-  verifyMultiSig,
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyMultiSig = exports.getBlockletEngine = exports.getBlockletInfo = exports.getBlockletWallet = exports.toBlockletDid = exports.fixName = exports.fixService = exports.fixInterfaces = exports.fixPerson = exports.parsePerson = exports.formatPerson = exports.fixAndValidateService = exports.validateMeta = exports.parse = exports.read = exports.update = exports.select = exports.list = exports.constants = void 0;
+const constants_1 = __importDefault(require("./constants"));
+exports.constants = constants_1.default;
+const parse_1 = __importDefault(require("./parse"));
+exports.parse = parse_1.default;
+const did_1 = __importDefault(require("./did"));
+exports.toBlockletDid = did_1.default;
+const wallet_1 = __importDefault(require("./wallet"));
+exports.getBlockletWallet = wallet_1.default;
+const info_1 = __importDefault(require("./info"));
+exports.getBlockletInfo = info_1.default;
+const engine_1 = __importDefault(require("./engine"));
+exports.getBlockletEngine = engine_1.default;
+const validate_1 = require("./validate");
+Object.defineProperty(exports, "validateMeta", { enumerable: true, get: function () { return validate_1.validateMeta; } });
+Object.defineProperty(exports, "fixAndValidateService", { enumerable: true, get: function () { return validate_1.fixAndValidateService; } });
+const fix_1 = require("./fix");
+Object.defineProperty(exports, "formatPerson", { enumerable: true, get: function () { return fix_1.formatPerson; } });
+Object.defineProperty(exports, "parsePerson", { enumerable: true, get: function () { return fix_1.parsePerson; } });
+Object.defineProperty(exports, "fixPerson", { enumerable: true, get: function () { return fix_1.fixPerson; } });
+Object.defineProperty(exports, "fixInterfaces", { enumerable: true, get: function () { return fix_1.fixInterfaces; } });
+Object.defineProperty(exports, "fixService", { enumerable: true, get: function () { return fix_1.fixService; } });
+Object.defineProperty(exports, "fixName", { enumerable: true, get: function () { return fix_1.fixName; } });
+const file_1 = require("./file");
+Object.defineProperty(exports, "list", { enumerable: true, get: function () { return file_1.list; } });
+Object.defineProperty(exports, "select", { enumerable: true, get: function () { return file_1.select; } });
+Object.defineProperty(exports, "update", { enumerable: true, get: function () { return file_1.update; } });
+Object.defineProperty(exports, "read", { enumerable: true, get: function () { return file_1.read; } });
+const verify_multi_sig_1 = __importDefault(require("./verify-multi-sig"));
+exports.verifyMultiSig = verify_multi_sig_1.default;
+exports.default = {
+    constants: constants_1.default,
+    list: file_1.list,
+    select: file_1.select,
+    update: file_1.update,
+    read: file_1.read,
+    parse: parse_1.default,
+    validateMeta: validate_1.validateMeta,
+    fixAndValidateService: validate_1.fixAndValidateService,
+    formatPerson: fix_1.formatPerson,
+    parsePerson: fix_1.parsePerson,
+    fixPerson: fix_1.fixPerson,
+    fixInterfaces: fix_1.fixInterfaces,
+    fixName: fix_1.fixName,
+    fixService: fix_1.fixService,
+    toBlockletDid: did_1.default,
+    getBlockletWallet: wallet_1.default,
+    getBlockletInfo: info_1.default,
+    getBlockletEngine: engine_1.default,
+    verifyMultiSig: verify_multi_sig_1.default,
 };

package/lib/info.d.ts

@@ -0,0 +1,15 @@
+import { WalletObject } from '@ocap/wallet';
+import { BlockletState } from '@abtnode/client';
+declare const getBlockletInfo: (state: BlockletState, nodeSk?: string, { returnWallet }?: {
+    returnWallet?: boolean;
+}) => {
+    did: string;
+    name: string;
+    version: string;
+    description: string;
+    passportColor: string;
+    appUrl: string;
+    wallet: WalletObject;
+    permanentWallet: WalletObject;
+};
+export = getBlockletInfo;

package/lib/info.js

@@ -1,39 +1,71 @@
-const get = require('lodash/get');
-const getBlockletWallet = require('./wallet');
-
-module.exports = (state, nodeSk) => {
-  if (!state || typeof state !== 'object' || !Array.isArray(state.environments) || !get(state, 'meta.did')) {
-    throw new Error('Blocklet state must be an object');
-  }
-  if (!nodeSk || typeof nodeSk !== 'string') {
-    throw new Error('Node secret key must be a string');
-  }
-
-  const customName = state.environments.find((x) => x.key === 'BLOCKLET_APP_NAME');
-  const customDescription = state.environments.find((x) => x.key === 'BLOCKLET_APP_DESCRIPTION');
-  const customSk = state.environments.find((x) => x.key === 'BLOCKLET_APP_SK');
-  const customType = state.environments.find((x) => x.key === 'BLOCKLET_WALLET_TYPE');
-
-  let type;
-  if (customType && customType.value === 'eth') {
-    type = customType.value;
-  }
-
-  let wallet = null;
-  if (customSk && customSk.value && customType) {
-    wallet = getBlockletWallet(customSk.value, null, type);
-  } else if (customSk && customSk.value) {
-    wallet = getBlockletWallet(customSk.value);
-  } else if (customType) {
-    wallet = getBlockletWallet(state.meta.did, nodeSk, type);
-  } else {
-    wallet = getBlockletWallet(state.meta.did, nodeSk);
-  }
-
-  return {
-    did: state.meta.did,
-    name: get(customName, 'value', state.meta.title || state.meta.name),
-    description: get(customDescription, 'value', state.meta.description),
-    wallet,
-  };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+const get_1 = __importDefault(require("lodash/get"));
+const wallet_1 = __importDefault(require("./wallet"));
+const util_1 = require("./util");
+const getBlockletInfo = (state, nodeSk, { returnWallet = true } = {}) => {
+    if (!state || typeof state !== 'object' || !Array.isArray(state.environments) || !(0, get_1.default)(state, 'meta.did')) {
+        throw new Error('Blocklet state must be an object');
+    }
+    const { environments, configs = [] } = state;
+    const envs = [...configs, ...environments];
+    const customDescription = envs.find((x) => x.key === 'BLOCKLET_APP_DESCRIPTION');
+    const customPassportColor = envs.find((x) => x.key === 'BLOCKLET_PASSPORT_COLOR');
+    const customAppUrl = envs.find((x) => x.key === 'BLOCKLET_APP_URL');
+    const { did, version } = state.meta;
+    const name = (0, util_1.getDisplayName)(state);
+    const description = (0, get_1.default)(customDescription, 'value', state.meta.description);
+    const passportColor = (0, get_1.default)(customPassportColor, 'value', 'auto');
+    const appUrl = (0, get_1.default)(customAppUrl, 'value', '');
+    if (!returnWallet) {
+        return {
+            did,
+            version,
+            name,
+            description,
+            passportColor,
+            appUrl,
+            wallet: null,
+            permanentWallet: null,
+        };
+    }
+    const customSk = envs.find((x) => x.key === 'BLOCKLET_APP_SK');
+    const customType = envs.find((x) => x.key === 'BLOCKLET_WALLET_TYPE');
+    const permanentSk = envs.find((x) => x.key === 'BLOCKLET_APP_PSK');
+    let type;
+    if (customType && customType.value === 'eth') {
+        type = customType.value;
+    }
+    let wallet = null;
+    let permanentWallet = null;
+    if (customSk && customSk.value) {
+        wallet = (0, wallet_1.default)(customSk.value, undefined, type);
+        if (permanentSk && permanentSk.value && permanentSk.value !== customSk.value) {
+            permanentWallet = (0, wallet_1.default)(permanentSk.value, undefined, type);
+        }
+    }
+    else {
+        if (!nodeSk || typeof nodeSk !== 'string') {
+            throw new Error('Node secret key must be a string');
+        }
+        if (customType) {
+            wallet = (0, wallet_1.default)(state.meta.did, nodeSk, type);
+        }
+        else {
+            wallet = (0, wallet_1.default)(state.meta.did, nodeSk);
+        }
+    }
+    return {
+        did,
+        version,
+        name,
+        description,
+        passportColor,
+        appUrl,
+        wallet,
+        permanentWallet: permanentWallet || wallet,
+    };
+};
+module.exports = getBlockletInfo;

package/lib/name.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 检查一个 did 是否为新版 blocklet-did（这里只需要判断是否为 ROLE_BLOCKLET 即可）
+ * @param did 需要检查是否为新版 did 的值
+ */
+export declare const validateNewDid: (did: string) => void;
+export declare const validateName: (name: string, { checkDid }?: {
+    checkDid?: boolean;
+}) => void;
+declare const _default: {
+    validateName: (name: string, { checkDid }?: {
+        checkDid?: boolean;
+    }) => void;
+    validateNewDid: (did: string) => void;
+};
+export default _default;

package/lib/name.js

@@ -1,10 +1,43 @@
-const validate = require('validate-npm-package-name');
-
-module.exports = {
-  validateName: (name) => {
-    const { validForNewPackages, errors = [], warnings = [] } = validate(name);
-    if (!validForNewPackages) {
-      throw new Error(errors[0] || warnings[0]);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateName = exports.validateNewDid = void 0;
+const did_1 = require("@arcblock/did");
+const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
+const MAX_NAME_LENGTH = 32;
+/**
+ * 检查一个 did 是否为新版 blocklet-did（这里只需要判断是否为 ROLE_BLOCKLET 即可）
+ * @param did 需要检查是否为新版 did 的值
+ */
+const validateNewDid = (did) => {
+    const typeInfo = (0, did_1.toTypeInfo)(did);
+    if (typeInfo.role !== did_1.types.RoleType.ROLE_BLOCKLET) {
+        throw new Error("Blocklet DID's type must be ROLE_BLOCKLET");
+    }
+};
+exports.validateNewDid = validateNewDid;
+const validateName = (name, { checkDid = true } = {}) => {
+    if ((0, did_1.isValid)(name)) {
+        // new did mode
+        if (checkDid) {
+            (0, exports.validateNewDid)(name);
+        }
     }
-  },
+    else {
+        // old did mode
+        const { validForNewPackages, errors = [], warnings = [] } = (0, validate_npm_package_name_1.default)(name);
+        if (!validForNewPackages) {
+            throw new Error(errors[0] || warnings[0]);
+        }
+        if (name.length > MAX_NAME_LENGTH) {
+            throw new Error('Blocklet name is too long');
+        }
+    }
+};
+exports.validateName = validateName;
+exports.default = {
+    validateName: exports.validateName,
+    validateNewDid: exports.validateNewDid,
 };

package/lib/nft-templates.d.ts

@@ -0,0 +1,86 @@
+declare const getBlockletPurchaseTemplate: (serviceUrl?: string) => {
+    type: string;
+    value: {
+        '@context': string;
+        id: string;
+        tag: string[];
+        type: string[];
+        issuer: {
+            id: string;
+            pk: string;
+            name: string;
+        };
+        issuanceDate: string;
+        credentialSubject: {
+            id: string;
+            sn: string;
+            purchased: {
+                blocklet: {
+                    id: string;
+                    url: string;
+                    name: string;
+                };
+            };
+            display: {
+                type: string;
+                content: string;
+            };
+        };
+        credentialStatus: {
+            id: string;
+            type: string;
+            scope: string;
+        };
+        proof: {
+            type: string;
+            created: string;
+            proofPurpose: string;
+            jws: string;
+        };
+    };
+};
+export { getBlockletPurchaseTemplate };
+declare const _default: {
+    getBlockletPurchaseTemplate: (serviceUrl?: string) => {
+        type: string;
+        value: {
+            '@context': string;
+            id: string;
+            tag: string[];
+            type: string[];
+            issuer: {
+                id: string;
+                pk: string;
+                name: string;
+            };
+            issuanceDate: string;
+            credentialSubject: {
+                id: string;
+                sn: string;
+                purchased: {
+                    blocklet: {
+                        id: string;
+                        url: string;
+                        name: string;
+                    };
+                };
+                display: {
+                    type: string;
+                    content: string;
+                };
+            };
+            credentialStatus: {
+                id: string;
+                type: string;
+                scope: string;
+            };
+            proof: {
+                type: string;
+                created: string;
+                proofPurpose: string;
+                jws: string;
+            };
+        };
+    };
+};
+export default _default;

package/lib/nft-templates.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockletPurchaseTemplate = void 0;
+const url_join_1 = __importDefault(require("url-join"));
+const getBlockletPurchaseTemplate = (serviceUrl = 'https://registry.arcblock.io') => ({
+    type: 'vc',
+    value: {
+        '@context': 'https://schema.arcblock.io/v0.1/context.jsonld',
+        id: '{{input.id}}',
+        tag: ['{{data.did}}'],
+        type: ['VerifiableCredential', 'PurchaseCredential', 'NFTCertificate', 'BlockletPurchaseCredential'],
+        issuer: {
+            id: '{{ctx.issuer.id}}',
+            pk: '{{ctx.issuer.pk}}',
+            name: '{{ctx.issuer.name}}',
+        },
+        issuanceDate: '{{input.issuanceDate}}',
+        credentialSubject: {
+            id: '{{ctx.owner}}',
+            sn: '{{ctx.id}}',
+            purchased: {
+                blocklet: {
+                    id: '{{data.did}}',
+                    url: '{{{data.url}}}',
+                    name: '{{data.name}}',
+                },
+            },
+            display: {
+                type: 'url',
+                content: (0, url_join_1.default)(serviceUrl, '/api/nft/display'), // accept asset-did in query param
+            },
+        },
+        credentialStatus: {
+            id: (0, url_join_1.default)(serviceUrl, '/api/nft/status'),
+            type: 'NFTStatusList2021',
+            scope: 'public',
+        },
+        proof: {
+            type: '{{input.proofType}}',
+            created: '{{input.issuanceDate}}',
+            proofPurpose: 'assertionMethod',
+            jws: '{{input.signature}}',
+        },
+    },
+});
+exports.getBlockletPurchaseTemplate = getBlockletPurchaseTemplate;
+exports.default = {
+    getBlockletPurchaseTemplate,
+};

package/lib/parse-navigation-from-blocklet.d.ts

@@ -0,0 +1,92 @@
+declare const checkLink: (value: string) => boolean;
+interface DeepWalkCallback {
+    (current: any, parent: any, options: DeepWalkCallbackOptions): void;
+}
+interface DeepWalkCallbackOptions {
+    index: number;
+    level: number;
+}
+/**
+ *
+ * @param {object} tree 需要深度遍历的数状结构
+ * @param {function} cb 每一个节点的回调函数，回调的参数：当前节点数据，父亲节点数据，{index:当前节点所属的数组中的序号，level: 当前节点所处的深度}
+ * @param {object} param 深度遍历的参数
+ * @param {string} param.key 孩子数组的 key 值
+ * @param {number} param.index 当前节点所属的数组中的序号
+ * @param {object} param.parent 当前节点的父节点
+ * @param {number} param.level 当前节点的深度
+ */
+type TreeNode<K extends string> = Record<string, any> & {
+    [key in K]?: TreeNode<K>[];
+};
+declare function deepWalk<K extends string>(tree: TreeNode<K>, cb: DeepWalkCallback, { key, order }: {
+    key: K;
+    order?: 'first' | 'last';
+}): void;
+declare function deepWalk(tree: TreeNode<'children'>, cb: DeepWalkCallback, { key, order }?: {
+    key?: 'children';
+    order?: 'first' | 'last';
+}): void;
+/**
+ * 判断一个传入值是否属于一个 section
+ * @param {string | array} sections 需要判断的对象
+ * @param {string} section 目标 section
+ */
+declare function isMatchSection(sections: string[] | string, section: string): boolean;
+interface NavigationItem {
+    id: string;
+    role?: string;
+    section?: string;
+    title?: string;
+    link?: string;
+    items?: NavigationItem[];
+    component?: string;
+    child?: string;
+    [key: string]: any;
+}
+interface ComponentItem {
+    name: string;
+    link: string;
+}
+declare function joinLink(navigation: NavigationItem, components: ComponentItem[]): NavigationItem;
+interface FlatternNavigationOption {
+    transform?: (current: any, parent?: any) => any;
+    depth?: number;
+}
+/**
+ * 将树状结构的导航列表进行扁平化处理
+ * @param {array} navigationList 树状结构的导航列表
+ * @param {object} params 配置参数
+ * @param {number} params.depth 扁平化的层级，默认为 1（全拍平）
+ * @param {function} params.transform 当发生拍平处理时
+ * @returns 扁平化后的导航列表
+ */
+declare function flatternNavigation(list?: NavigationItem[], { depth, transform }?: FlatternNavigationOption): any[];
+/**
+ * 根据导航中每一个子菜单所属的 section，将原由的导航数据分离为多个导航数据（此时每一个导航 item 只会包含一个 section）
+ * @param {array} navigation 导航列表数据（树状结构，目前只适用于两层的树状结构）
+ * @returns
+ */
+declare function splitNavigationBySection(navigation: NavigationItem[]): any[];
+/**
+ * 将导航数据进行层叠处理
+ * @param {array} list 扁平化的导航数据
+ * @returns 处理后的导航
+ */
+declare function nestNavigationList(list?: any[]): any[];
+declare function filterNavigation(navigationList: NavigationItem[], components?: ComponentItem[]): any[];
+declare function cleanOrphanNavigation(list: NavigationItem[]): NavigationItem[];
+interface Blocklet {
+    settings?: {
+        navigations?: NavigationItem[];
+    };
+}
+interface ParseNavigationOption {
+    beforeProcess?: (data: any) => any;
+}
+declare function parseNavigation(blocklet?: Blocklet, options?: ParseNavigationOption): {
+    navigationList: any[];
+    components: any[];
+    builtinList: any[];
+};
+export { parseNavigation, deepWalk, isMatchSection, nestNavigationList, filterNavigation, cleanOrphanNavigation, joinLink, checkLink, flatternNavigation, splitNavigationBySection, };