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

package/lib/parse-navigation.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const get_1 = __importDefault(require("lodash/get"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const normalize_path_prefix_1 = __importDefault(require("@abtnode/util/lib/normalize-path-prefix"));
+const parseLinkString = (link, prefix = '') => link.startsWith('/') ? (0, normalize_path_prefix_1.default)(`${prefix}${link || '/'}`) : link;
+const parseLink = (input, prefix) => {
+    if (Object.prototype.toString.call(input) === '[object Object]') {
+        return Object.entries(input).reduce((o, [key, value]) => {
+            o[key] = parseLinkString(value, prefix);
+            return o;
+        }, {});
+    }
+    return parseLinkString(input, prefix);
+};
+const getGroups = (navigation) => {
+    const groups = {};
+    for (const nav of navigation) {
+        const sections = !nav.section || !nav.section.length ? ['__undefined__'] : nav.section;
+        for (const sec of sections) {
+            if (!groups[sec]) {
+                groups[sec] = [];
+            }
+            const item = {
+                ...nav,
+            };
+            if (nav.section) {
+                item.section = sec === '__undefined__' ? [] : [sec];
+            }
+            groups[sec].push(item);
+        }
+    }
+    return Object.values(groups);
+};
+const getChildName = (nav) => nav.component || nav.child;
+const doParseNavigation = (navigation, blocklet, prefix = '/', _level = 1) => {
+    const result = [];
+    (navigation || []).forEach((nav) => {
+        if (!getChildName(nav)) {
+            if (_level > 1 && nav.items?.length) {
+                const list = doParseNavigation(nav.items, blocklet, prefix, _level + 1);
+                result.push(...list);
+                return;
+            }
+            const item = {
+                title: nav.title,
+                id: undefined,
+            };
+            if (nav.section) {
+                item.section = nav.section;
+            }
+            if (nav.icon) {
+                item.icon = nav.icon;
+            }
+            if (nav.link) {
+                item.link = parseLink(nav.link, prefix);
+            }
+            else {
+                item.link = '';
+            }
+            if (nav.role) {
+                item.role = nav.role;
+            }
+            if (nav.items?.length) {
+                const list = doParseNavigation(nav.items, blocklet, prefix, _level + 1);
+                if (list.length) {
+                    item.items = list;
+                }
+            }
+            result.push(item);
+            return;
+        }
+        if (!blocklet) {
+            return;
+        }
+        // parse child
+        const child = (blocklet.children || []).find((x) => [x.meta.name, x.meta.did].includes(getChildName(nav)));
+        if (!child) {
+            return;
+        }
+        const childTitle = child.meta.title || child.meta.name;
+        const itemProto = {
+            title: nav.title || childTitle,
+            id: undefined,
+        };
+        if (nav.section) {
+            itemProto.section = nav.section;
+        }
+        if (nav.icon) {
+            itemProto.icon = nav.icon;
+        }
+        if (nav.role) {
+            itemProto.role = nav.role;
+        }
+        // get groups by section
+        const groups = getGroups((0, get_1.default)(child, 'meta.navigation', []));
+        if (!groups.length) {
+            // child does not declares menu
+            const item = (0, cloneDeep_1.default)(itemProto);
+            item.link = parseLink(child.mountPoint || '/', prefix);
+            result.push(item);
+        }
+        else {
+            for (const childNavigation of groups) {
+                if (childNavigation.length === 1) {
+                    // child declares one menu
+                    const childNav = childNavigation[0];
+                    const item = (0, cloneDeep_1.default)(itemProto);
+                    item.title = nav.title || childNav.title || childTitle;
+                    if (childNav.icon) {
+                        item.icon = item.icon || childNav.icon;
+                    }
+                    if (childNav.role) {
+                        item.role = item.role || childNav.role;
+                    }
+                    if (childNav.section) {
+                        item.section = item.section || childNav.section;
+                    }
+                    item.link = parseLink(childNavigation[0].link || '/', (0, normalize_path_prefix_1.default)(`${prefix}${child.mountPoint}`));
+                    // doParseNavigation because child nav depth may be > 1
+                    const list = doParseNavigation(childNavigation, child, (0, normalize_path_prefix_1.default)(`${prefix}${child.mountPoint}`), _level + 1);
+                    if (list.length > 1) {
+                        // more than 1 child nav
+                        delete item.link;
+                        result.push({
+                            ...item,
+                            items: list,
+                        });
+                    }
+                    else {
+                        // only 1 child nav
+                        item.link = list[0].link;
+                        result.push(item);
+                    }
+                }
+                else {
+                    // child declares multiple menus
+                    const groupSection = childNavigation[0].section || [];
+                    const list = doParseNavigation(childNavigation, child, (0, normalize_path_prefix_1.default)(`${prefix}${child.mountPoint}`), _level + 1);
+                    if (_level === 1) {
+                        // primary menu
+                        const item = (0, cloneDeep_1.default)(itemProto);
+                        if (groupSection.length) {
+                            item.section = item.section || groupSection;
+                        }
+                        item.items = list;
+                        result.push({
+                            ...item,
+                            items: list,
+                        });
+                    }
+                    else {
+                        // secondary menu
+                        result.push(...list);
+                    }
+                }
+            }
+        }
+    });
+    return result;
+};
+const markDuplicate = (navigation, compares = []) => {
+    navigation.forEach((item) => {
+        const compare = { link: item.link, section: item.section || [] };
+        if (item.link && compares.some((x) => (0, isEqual_1.default)(x, compare))) {
+            item.duplicate = true;
+        }
+        if (item.link) {
+            compares.push(compare);
+        }
+        if (item.items) {
+            markDuplicate(item.items, compares);
+        }
+    });
+    return navigation;
+};
+const filterDuplicate = (navigation) => {
+    const res = navigation.filter((x) => !x.duplicate);
+    res.forEach((item) => {
+        if (item.items) {
+            item.items = filterDuplicate(item.items);
+        }
+    });
+    return res;
+};
+const uniq = (navigation) => {
+    return filterDuplicate(markDuplicate(navigation));
+};
+const parseNavigation = (...args) => {
+    // @ts-expect-error
+    const res = doParseNavigation(...args);
+    return uniq(res).filter((x) => x.link || (x.items && x.items.length));
+};
+module.exports = parseNavigation;

package/lib/parse.d.ts

@@ -0,0 +1,22 @@
+import { TBlockletMeta, TComponent } from './types';
+/**
+ * Get blocklet meta from blocklet.yml
+ * @param {string} dir blocklet directory
+ * @param {object} options.extraRawAttrs extra attributes, will be used as base attributes
+ * @param {boolean} options.ensureMain should we verify that main exists
+ * @param {boolean} options.ensureDist should we verify that dist exists
+ * @param {boolean} options.ensureFiles should we verify that logo and files exists
+ */
+declare const 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: TComponent) => string);
+    fix?: boolean;
+}) => TBlockletMeta;
+export = parse;

package/lib/parse.js

@@ -1,102 +1,113 @@
-const fs = require('fs');
-const path = require('path');
-const yaml = require('js-yaml');
-const camelCase = require('lodash/camelCase');
-const debug = require('debug')('@blocklet/meta:fix');
-
-const { BLOCKLET_META_FILE, BLOCKLET_META_FILE_ALT, BLOCKLET_META_FILE_OLD } = require('./constants');
-
-const toBlockletDid = require('./did');
-const { createBlockletSchema } = require('./schema');
-const { fixRequired, fixRepository, fixFiles, fixPerson, fixKeywords, fixTags, fixService } = require('./fix');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const camelCase_1 = __importDefault(require("lodash/camelCase"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const debug_1 = __importDefault(require("debug"));
+const constants_1 = __importDefault(require("./constants"));
+const schema_1 = require("./schema");
+const fix_1 = require("./fix");
+const debug = (0, debug_1.default)('@blocklet/meta:parse');
+const { BLOCKLET_META_FILE, BLOCKLET_META_FILE_ALT } = constants_1.default;
+const isSourceFromStore = (source) => 'name' in source || 'did' in source;
 /**
- * Get blocklet meta from blocklet.yml > blocklet.json > package.json
+ * Get blocklet meta from blocklet.yml
  * @param {string} dir blocklet directory
  * @param {object} options.extraRawAttrs extra attributes, will be used as base attributes
  * @param {boolean} options.ensureMain should we verify that main exists
  * @param {boolean} options.ensureDist should we verify that dist exists
  * @param {boolean} options.ensureFiles should we verify that logo and files exists
- * @param {Array} options.serviceMetas should we verify that each service is validate (using JSON Schema defined serviceMetas)
  */
-const parse = (
-  dir,
-  { ensureMain = false, ensureFiles = false, ensureDist = false, extraRawAttrs = {}, serviceMetas } = {}
-) => {
-  let result = {};
-  const packageFile = path.join(dir, 'package.json');
-  if (fs.existsSync(packageFile)) {
-    try {
-      const packageJson = JSON.parse(fs.readFileSync(packageFile).toString());
-      delete packageJson.scripts;
-      result = Object.assign(result, packageJson, packageJson.blocklet || {});
-      debug('parse package.json', result);
-    } catch (err) {
-      console.error('parse_blocklet_meta from package.json failed', err);
+const parse = (dir, { ensureMain = false, ensureFiles = false, ensureDist = false, ensureComponentStore = true, extraRawAttrs = {}, schemaOptions = {}, defaultStoreUrl, fix = true, } = {}) => {
+    let result;
+    const blockletMetaFile = path_1.default.join(dir, BLOCKLET_META_FILE);
+    const blockletMetaFileAlt = path_1.default.join(dir, BLOCKLET_META_FILE_ALT);
+    if (fs_1.default.existsSync(blockletMetaFile)) {
+        try {
+            result = js_yaml_1.default.load(fs_1.default.readFileSync(blockletMetaFile).toString(), { json: true });
+            debug(`parse ${blockletMetaFile}`, result);
+        }
+        catch (err) {
+            console.error(`parse_blocklet_meta from ${BLOCKLET_META_FILE} failed`, err);
+        }
+    }
+    else if (fs_1.default.existsSync(blockletMetaFileAlt)) {
+        try {
+            result = Object.assign({}, js_yaml_1.default.load(fs_1.default.readFileSync(blockletMetaFileAlt).toString(), { json: true }));
+            debug(`parse ${blockletMetaFileAlt}`, result);
+        }
+        catch (err) {
+            console.error(`parse_blocklet_meta from ${BLOCKLET_META_FILE_ALT} failed`, err);
+        }
+    }
+    else {
+        throw new Error(`no ${BLOCKLET_META_FILE} or ${BLOCKLET_META_FILE_ALT} found`);
     }
-  }
-
-  const blockletMetaFileOld = path.join(dir, BLOCKLET_META_FILE_OLD);
-  if (fs.existsSync(blockletMetaFileOld)) {
-    try {
-      result = Object.assign(result, JSON.parse(fs.readFileSync(blockletMetaFileOld).toString()));
-      debug(`parse ${BLOCKLET_META_FILE_OLD}`, result);
-    } catch (err) {
-      console.error(`parse_blocklet_meta from ${BLOCKLET_META_FILE_OLD} failed`, err);
+    // User Can override with extra meta attrs: useful for registry
+    if (extraRawAttrs) {
+        result = Object.assign(result, extraRawAttrs);
     }
-  }
-
-  const blockletMetaFile = path.join(dir, BLOCKLET_META_FILE);
-  const blockletMetaFileAlt = path.join(dir, BLOCKLET_META_FILE_ALT);
-  if (fs.existsSync(blockletMetaFile)) {
-    try {
-      result = Object.assign(result, yaml.safeLoad(fs.readFileSync(blockletMetaFile).toString(), { json: true }));
-      debug(`parse ${blockletMetaFile}`, result);
-    } catch (err) {
-      console.error(`parse_blocklet_meta from ${BLOCKLET_META_FILE} failed`, err);
+    if (!fix) {
+        // @ts-ignore
+        return result;
     }
-  } else if (fs.existsSync(blockletMetaFileAlt)) {
-    try {
-      result = Object.assign(result, yaml.safeLoad(fs.readFileSync(blockletMetaFileAlt).toString(), { json: true }));
-      debug(`parse ${blockletMetaFileAlt}`, result);
-    } catch (err) {
-      console.error(`parse_blocklet_meta from ${BLOCKLET_META_FILE_ALT} failed`, err);
+    // Fix
+    (0, fix_1.fixRequired)(result, dir);
+    (0, fix_1.fixRepository)(result);
+    (0, fix_1.fixFiles)(result);
+    (0, fix_1.fixKeywords)(result);
+    (0, fix_1.fixTags)(result);
+    (0, fix_1.fixName)(result);
+    (0, fix_1.fixPerson)(result);
+    (0, fix_1.fixService)(result);
+    ['components', 'staticComponents'].forEach((prop) => {
+        if (defaultStoreUrl && result[prop]?.length) {
+            result[prop].forEach((x) => {
+                if (isSourceFromStore(x.source)) {
+                    if (!x.source.store) {
+                        x.source.store = typeof defaultStoreUrl === 'function' ? defaultStoreUrl((0, cloneDeep_1.default)(x)) : defaultStoreUrl;
+                    }
+                }
+            });
+        }
+    });
+    // We will overwrite did anyway
+    result.path = `/${result.group}/${result.name}`;
+    // Ensure camelCase
+    result = Object.keys(result).reduce((acc, k) => {
+        acc[(0, camelCase_1.default)(k)] = result[k];
+        return acc;
+    }, {});
+    debug('fix', result);
+    // Validate and cleanup
+    const schema = (0, schema_1.createBlockletSchema)(dir, {
+        ensureMain,
+        ensureFiles,
+        ensureDist,
+        ensureComponentStore,
+        ...schemaOptions,
+    });
+    const { value, error } = schema.validate(result);
+    if (error) {
+        throw new Error(`Invalid blocklet.yml: ${error.details
+            .map((x) => {
+            try {
+                // 根据 navigation 校验规则定制特殊的错误消息显示
+                if (x.type === 'array.unique' && x.path[0] === 'navigation') {
+                    return `${x.message}: ${x.context.value.id}`;
+                }
+            }
+            catch {
+                //
+            }
+            return x.message;
+        })
+            .join(', ')}`);
     }
-  }
-
-  // User Can override with extra meta attrs: useful for registry
-  if (extraRawAttrs) {
-    result = Object.assign(result, extraRawAttrs);
-  }
-
-  // Fix
-  fixRequired(result, dir);
-  fixRepository(result);
-  fixFiles(result);
-  fixKeywords(result);
-  fixTags(result);
-  fixPerson(result);
-  fixService(result, serviceMetas);
-  debug('fix', result);
-
-  // We will overwrite did anyway
-  result.path = `/${result.group}/${result.name}`;
-  result.did = toBlockletDid(Buffer.from(result.name, 'utf8'));
-
-  // Ensure camelCase
-  result = Object.keys(result).reduce((acc, k) => {
-    acc[camelCase(k)] = result[k];
-    return acc;
-  }, {});
-
-  // Validate and cleanup
-  const schema = createBlockletSchema(dir, { ensureMain, ensureFiles, ensureDist });
-  const { value, error } = schema.validate(result);
-  if (error) {
-    throw new Error(`Invalid blocklet meta: ${error.details.map((x) => x.message).join(', ')}`);
-  }
-
-  return value;
+    return value;
 };
-
 module.exports = parse;

package/lib/payment/index.d.ts

@@ -0,0 +1,254 @@
+import v2 from './v2';
+export declare const createNftFactoryItx: ({ meta, tokens, shares, issuers, serviceUrl, }: {
+    meta: import("../types").TBlockletMeta;
+    tokens: Pick<import("@abtnode/client").BlockletPaymentPrice, "address" | "value">[];
+    shares: {
+        value: number;
+        address: string;
+    }[];
+    issuers: string[];
+    serviceUrl: string;
+}) => {
+    name: string;
+    description: string;
+    settlement: string;
+    limit: number;
+    trustedIssuers: string[];
+    input: {
+        tokens: Pick<import("@abtnode/client").BlockletPaymentPrice, "address" | "value">[];
+        assets: any[];
+        variables: any[];
+    };
+    output: {
+        issuer: string;
+        parent: string;
+        moniker: string;
+        readonly: boolean;
+        transferrable: boolean;
+        data: {
+            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;
+                };
+            };
+        };
+    };
+    data: {
+        type: string;
+        value: {
+            did: string;
+            url: string;
+            name: string;
+        };
+    };
+    hooks: {
+        name: string;
+        type: string;
+        hook: string;
+    }[];
+};
+export { v2 };
+declare const _default: {
+    createNftFactoryItx: ({ meta, tokens, shares, issuers, serviceUrl, }: {
+        meta: import("../types").TBlockletMeta;
+        tokens: Pick<import("@abtnode/client").BlockletPaymentPrice, "address" | "value">[];
+        shares: {
+            value: number;
+            address: string;
+        }[];
+        issuers: string[];
+        serviceUrl: string;
+    }) => {
+        name: string;
+        description: string;
+        settlement: string;
+        limit: number;
+        trustedIssuers: string[];
+        input: {
+            tokens: Pick<import("@abtnode/client").BlockletPaymentPrice, "address" | "value">[];
+            assets: any[];
+            variables: any[];
+        };
+        output: {
+            issuer: string;
+            parent: string;
+            moniker: string;
+            readonly: boolean;
+            transferrable: boolean;
+            data: {
+                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;
+                    };
+                };
+            };
+        };
+        data: {
+            type: string;
+            value: {
+                did: string;
+                url: string;
+                name: string;
+            };
+        };
+        hooks: {
+            name: string;
+            type: string;
+            hook: string;
+        }[];
+    };
+    v2: {
+        createNftFactoryItx: ({ blockletMeta, ocapClient, issuers, storeUrl, }: {
+            blockletMeta: import("../types").TBlockletMeta;
+            ocapClient: any;
+            issuers: string[];
+            storeUrl: string;
+        }) => Promise<{
+            itx: any;
+            stores: {
+                id: string;
+                url: string;
+            }[];
+            shares: {
+                amount: string;
+                tokenAddress: string;
+                accountAddress: string;
+            }[];
+        }>;
+        verifyPaymentIntegrity: ({ integrity: expected, blockletMeta, ocapClient, storeId, }: {
+            integrity: string;
+            blockletMeta: import("../types").TBlockletMeta;
+            ocapClient: any;
+            storeId: string;
+        }) => Promise<string>;
+        verifyNftFactory: ({ factoryState, signerWallet, }: {
+            factoryState: {
+                data: {
+                    value: string;
+                };
+                input?: any;
+                address?: string;
+                hooks?: {
+                    type: string;
+                    hook: string;
+                }[];
+            };
+            signerWallet: any;
+        }) => Promise<any>;
+        checkFreeBlocklet: (blockletMeta: import("../types").TBlockletMeta) => Promise<boolean>;
+        version: string;
+        _test: {
+            getPriceTokens: (meta: any, ocapClient: any) => Promise<any>;
+            getFactoryInput: (inputTokens: {
+                address: string;
+                value: string | number;
+                decimal: number;
+            }[], { formatToken }?: {
+                formatToken?: boolean;
+            }) => {
+                tokens: {
+                    address: string;
+                    value: string | number;
+                    decimal: number;
+                }[];
+                assets: [];
+                variables: [];
+            };
+            getPaymentIntegrity: ({ contract, factoryInput, storeComponents, meta, client, storeId, }: {
+                contract?: string;
+                factoryInput?: any;
+                storeComponents?: any;
+                meta?: any;
+                client?: any;
+                storeId?: string;
+            }) => Promise<string>;
+            getComponents: (inputMeta: any) => Promise<{
+                components: import("./v2").Component[];
+                stores: import("./v2").Store[];
+            }>;
+            getContract: ({ meta, priceTokens, components, }: {
+                meta: import("../types").TBlockletMeta;
+                priceTokens: {
+                    decimal: number;
+                }[];
+                components: any;
+            }) => Promise<{
+                code: string;
+                shares: {
+                    amount: string;
+                    tokenAddress: string;
+                    accountAddress: string;
+                }[];
+            }>;
+        };
+    };
+};
+export default _default;

package/lib/payment/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2 = exports.createNftFactoryItx = void 0;
+const v1_1 = __importDefault(require("./v1"));
+const v2_1 = __importDefault(require("./v2"));
+exports.v2 = v2_1.default;
+exports.createNftFactoryItx = v1_1.default.createNftFactoryItx;
+exports.default = {
+    createNftFactoryItx: exports.createNftFactoryItx,
+    v2: v2_1.default,
+};