@blocklet/meta 1.8.33 → 1.8.35

package/lib/fix.d.ts

@@ -0,0 +1,33 @@
+import { fixAndValidateService } from './validate';
+declare const fixRequired: (data: any, dir: string) => void;
+declare const fixRepository: (data: any) => void;
+declare const fixFiles: (data: any) => void;
+declare const fixKeywords: (data: any) => void;
+declare const fixTags: (data: any) => void;
+declare const formatPerson: (person: string | Record<string, any>) => string;
+declare const parsePerson: (person: string) => any;
+declare const fixPerson: (data: any) => any;
+declare const fixInterfaces: (meta: any, removeMerged?: boolean) => any;
+export { fixRequired };
+export { fixRepository };
+export { fixFiles };
+export { fixKeywords };
+export { fixPerson };
+export { fixTags };
+export { formatPerson };
+export { parsePerson };
+export { fixInterfaces };
+export { fixAndValidateService as fixService };
+declare const _default: {
+    fixRequired: (data: any, dir: string) => void;
+    fixRepository: (data: any) => void;
+    fixFiles: (data: any) => void;
+    fixKeywords: (data: any) => void;
+    fixPerson: (data: any) => any;
+    fixTags: (data: any) => void;
+    formatPerson: (person: string | Record<string, any>) => string;
+    parsePerson: (person: string) => any;
+    fixInterfaces: (meta: any, removeMerged?: boolean) => any;
+    fixService: (meta: import("./types").TBlockletMeta) => import("./types").TBlockletMeta;
+};
+export default _default;

package/lib/fix.js

@@ -1,235 +1,245 @@
-/* eslint-disable prefer-destructuring */
-const fs = require('fs');
-const path = require('path');
-const get = require('lodash/get');
-const gitInfo = require('hosted-git-info');
-const debug = require('debug')('@blocklet/meta:fix');
-
-const { fixAndValidateService } = require('./validate');
-const {
-  BLOCKLET_DEFAULT_VERSION,
-  BLOCKLET_DEFAULT_PORT_NAME,
-  BLOCKLET_DYNAMIC_PATH_PREFIX,
-  BLOCKLET_INTERFACE_TYPE_WEB,
-  BLOCKLET_INTERFACE_PUBLIC,
-} = require('./constants');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixService = exports.fixInterfaces = exports.parsePerson = exports.formatPerson = exports.fixTags = exports.fixPerson = exports.fixKeywords = exports.fixFiles = exports.fixRepository = exports.fixRequired = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const get_1 = __importDefault(require("lodash/get"));
+const gitInfo = __importStar(require("hosted-git-info"));
+const debug_1 = __importDefault(require("debug"));
+const validate_1 = require("./validate");
+Object.defineProperty(exports, "fixService", { enumerable: true, get: function () { return validate_1.fixAndValidateService; } });
+const constants_1 = __importDefault(require("./constants"));
+const debug = (0, debug_1.default)('@blocklet/meta:fix');
+const { BLOCKLET_DEFAULT_VERSION, BLOCKLET_DEFAULT_PORT_NAME, BLOCKLET_DYNAMIC_PATH_PREFIX, BLOCKLET_INTERFACE_TYPE_WEB, BLOCKLET_INTERFACE_PUBLIC, } = constants_1.default;
 // Assign sensible defaults: name/description/main/group/version/public_url
 const fixRequired = (data, dir) => {
-  if (!data.name) {
-    data.name = path.basename(dir);
-  }
-
-  if (!data.description) {
-    data.description = `Blocklet from ${dir}`;
-  }
-
-  if (!data.version) {
-    data.version = BLOCKLET_DEFAULT_VERSION;
-  }
-
-  if (!data.main && !data.group) {
-    debug('guess main and group', dir);
-    data.group = 'static';
-
-    const items = ['.'].concat(fs.readdirSync(dir));
-    const item = items.find(
-      (x) => fs.existsSync(path.resolve(dir, x, 'index.html')) || fs.existsSync(path.resolve(dir, x, 'index.htm'))
-    );
-    if (item) {
-      data.main = item;
-    }
-  }
-
-  if (!data.group) {
-    const main = path.join(dir, data.main);
-    try {
-      const stat = fs.statSync(main);
-      if (stat.isDirectory()) {
+    if (!data.name) {
+        data.name = path_1.default.basename(dir);
+    }
+    if (!data.description) {
+        data.description = `Blocklet from ${dir}`;
+    }
+    if (!data.version) {
+        data.version = BLOCKLET_DEFAULT_VERSION;
+    }
+    if (!data.main && !data.group) {
+        debug('guess main and group', dir);
         data.group = 'static';
-      } else {
-        data.group = 'dapp';
-      }
-    } catch (err) {
-      data.group = 'static';
+        const items = ['.'].concat(fs_1.default.readdirSync(dir));
+        const item = items.find((x) => fs_1.default.existsSync(path_1.default.resolve(dir, x, 'index.html')) || fs_1.default.existsSync(path_1.default.resolve(dir, x, 'index.htm')));
+        if (item) {
+            data.main = item;
+        }
+    }
+    if (!data.group) {
+        const main = path_1.default.join(dir, data.main);
+        try {
+            const stat = fs_1.default.statSync(main);
+            if (stat.isDirectory()) {
+                data.group = 'static';
+            }
+            else {
+                data.group = 'dapp';
+            }
+        }
+        catch (err) {
+            data.group = 'static';
+        }
     }
-  }
 };
-
+exports.fixRequired = fixRequired;
 const fixRepository = (data) => {
-  if (!data.repository) return;
-  if (typeof data.repository === 'string') {
-    data.repository = {
-      type: 'git',
-      url: data.repository,
-    };
-  }
-  if (data.repository.url) {
-    const info = gitInfo.fromUrl(data.repository.url);
-    if (info) {
-      data.repository.url = info.getDefaultRepresentation() === 'shortcut' ? info.https() : info.toString();
+    if (!data.repository)
+        return;
+    if (typeof data.repository === 'string') {
+        data.repository = {
+            type: 'git',
+            url: data.repository,
+        };
+    }
+    if (data.repository.url) {
+        const info = gitInfo.fromUrl(data.repository.url);
+        if (info) {
+            data.repository.url = info.getDefaultRepresentation() === 'shortcut' ? info.https() : info.toString();
+        }
     }
-  }
 };
-
+exports.fixRepository = fixRepository;
 const fixFiles = (data) => {
-  if (!Array.isArray(data.files)) {
-    delete data.files;
-  } else if (data.files) {
-    data.files = data.files.filter((file) => {
-      return !(!file || typeof file !== 'string');
-    });
-  }
+    if (!Array.isArray(data.files)) {
+        delete data.files;
+    }
+    else if (data.files) {
+        data.files = data.files.filter((file) => {
+            return !(!file || typeof file !== 'string');
+        });
+    }
 };
-
+exports.fixFiles = fixFiles;
 const fixKeywords = (data) => {
-  if (typeof data.keywords === 'string') {
-    data.keywords = data.keywords.split(/,\s+/);
-  }
-  if (data.keywords && !Array.isArray(data.keywords)) {
-    delete data.keywords;
-  } else if (data.keywords) {
-    data.keywords = data.keywords.filter((kw) => {
-      return !(typeof kw !== 'string' || !kw);
-    });
-  }
+    if (typeof data.keywords === 'string') {
+        data.keywords = data.keywords.split(/,\s+/);
+    }
+    if (data.keywords && !Array.isArray(data.keywords)) {
+        delete data.keywords;
+    }
+    else if (data.keywords) {
+        data.keywords = data.keywords.filter((kw) => {
+            return !(typeof kw !== 'string' || !kw);
+        });
+    }
 };
-
+exports.fixKeywords = fixKeywords;
 const fixTags = (data) => {
-  if (typeof data.tags === 'string') {
-    data.tags = data.tags.split(/,\s+/);
-  }
-  if (data.tags && !Array.isArray(data.tags)) {
-    delete data.tags;
-  } else if (data.tags) {
-    data.tags = data.tags.filter((t) => {
-      return !(typeof t !== 'string' || !t);
-    });
-  }
+    if (typeof data.tags === 'string') {
+        data.tags = data.tags.split(/,\s+/);
+    }
+    if (data.tags && !Array.isArray(data.tags)) {
+        delete data.tags;
+    }
+    else if (data.tags) {
+        data.tags = data.tags.filter((t) => {
+            return !(typeof t !== 'string' || !t);
+        });
+    }
 };
-
+exports.fixTags = fixTags;
 const updatePerson = (data, fn) => {
-  if (data.author) data.author = fn(data.author);
-  ['maintainers', 'contributors'].forEach((key) => {
-    if (!Array.isArray(data[key])) {
-      return;
-    }
-    data[key] = data[key].map(fn);
-  });
-
-  return data;
+    if (data.author)
+        data.author = fn(data.author);
+    ['maintainers', 'contributors'].forEach((key) => {
+        if (!Array.isArray(data[key])) {
+            return;
+        }
+        data[key] = data[key].map(fn);
+    });
+    return data;
 };
-
 const formatPerson = (person) => {
-  if (!person) {
-    return '';
-  }
-  if (typeof person === 'string') {
-    return person;
-  }
-  const name = person.name || '';
-  const u = person.url || person.web;
-  const url = u ? ` (${u})` : '';
-  const e = person.email || person.mail;
-  const email = e ? ` <${e}>` : '';
-  return name + email + url;
+    if (!person) {
+        return '';
+    }
+    if (typeof person === 'string') {
+        return person;
+    }
+    const name = person.name || '';
+    const u = person.url || person.web;
+    const url = u ? ` (${u})` : '';
+    const e = person.email || person.mail;
+    const email = e ? ` <${e}>` : '';
+    return name + email + url;
 };
-
+exports.formatPerson = formatPerson;
 const parsePerson = (person) => {
-  if (typeof person !== 'string') {
-    return person;
-  }
-  const name = person.match(/^([^(<]+)/);
-  const url = person.match(/\(([^)]+)\)/);
-  const email = person.match(/<([^>]+)>/);
-  const obj = {};
-  if (name && name[0].trim()) obj.name = name[0].trim();
-  if (email) {
-    obj.email = email[1];
-  }
-  if (url) {
-    obj.url = url[1];
-  }
-  return obj;
+    if (typeof person !== 'string') {
+        return person;
+    }
+    const name = person.match(/^([^(<]+)/);
+    const url = person.match(/\(([^)]+)\)/);
+    const email = person.match(/<([^>]+)>/);
+    const obj = {};
+    if (name && name[0].trim())
+        obj.name = name[0].trim();
+    if (email) {
+        [, obj.email] = email;
+    }
+    if (url) {
+        [, obj.url] = url;
+    }
+    return obj;
 };
-
+exports.parsePerson = parsePerson;
 const fixPerson = (data) => {
-  updatePerson(data, formatPerson);
-  updatePerson(data, parsePerson);
-  return data;
+    updatePerson(data, formatPerson);
+    updatePerson(data, parsePerson);
+    return data;
 };
-
+exports.fixPerson = fixPerson;
 const fixInterfaces = (meta, removeMerged = true) => {
-  if (!Array.isArray(meta.interfaces)) {
-    meta.interfaces = [];
-  }
-
-  if (meta.interfaces.length) {
-    // Web interfaces should always use http protocol
-    meta.interfaces.forEach((x) => {
-      if (x.type === BLOCKLET_INTERFACE_TYPE_WEB) {
-        x.protocol = 'http';
-      }
+    if (!Array.isArray(meta.interfaces)) {
+        meta.interfaces = [];
+    }
+    if (meta.interfaces.length) {
+        // Web interfaces should always use http protocol
+        meta.interfaces.forEach((x) => {
+            if (x.type === BLOCKLET_INTERFACE_TYPE_WEB) {
+                x.protocol = 'http';
+            }
+        });
+        return meta;
+    }
+    const supportDynamicPathPrefix = (0, get_1.default)(meta, 'capabilities.dynamicPathPrefix', true);
+    const prefix = supportDynamicPathPrefix ? BLOCKLET_DYNAMIC_PATH_PREFIX : '/';
+    const addInterface = ({ type = 'web', name, path: _path = '/', // eslint-disable-line no-shadow
+    protocol = 'http', port = BLOCKLET_DEFAULT_PORT_NAME, }) => {
+        meta.interfaces.push({ type, name, path: _path, prefix, port, protocol });
+    };
+    [BLOCKLET_INTERFACE_PUBLIC].forEach((x) => {
+        if (meta[x]) {
+            addInterface({ name: x, path: meta[x] });
+        }
     });
+    if (Array.isArray(meta.exposeServices)) {
+        meta.exposeServices.forEach((x) => {
+            addInterface({
+                type: 'service',
+                name: x.protocol,
+                protocol: x.protocol,
+                port: {
+                    internal: `BLOCKLET_${x.protocol}_PORT`.toUpperCase(),
+                    external: x.port,
+                },
+            });
+        });
+    }
+    if (removeMerged) {
+        delete meta.publicUrl;
+        delete meta.adminUrl;
+        delete meta.configUrl;
+        delete meta.docUrl;
+        delete meta.exposeServices;
+        if (meta.capabilities) {
+            delete meta.capabilities.dynamicPathPrefix;
+        }
+    }
     return meta;
-  }
-
-  const supportDynamicPathPrefix = get(meta, 'capabilities.dynamicPathPrefix', true);
-  const prefix = supportDynamicPathPrefix ? BLOCKLET_DYNAMIC_PATH_PREFIX : '/';
-
-  const addInterface = ({
-    type = 'web',
-    name,
-    path = '/', // eslint-disable-line no-shadow
-    protocol = 'http',
-    port = BLOCKLET_DEFAULT_PORT_NAME,
-  }) => {
-    meta.interfaces.push({ type, name, path, prefix, port, protocol });
-  };
-
-  [BLOCKLET_INTERFACE_PUBLIC].forEach((x) => {
-    if (meta[x]) {
-      addInterface({ name: x, path: meta[x] });
-    }
-  });
-
-  if (Array.isArray(meta.exposeServices)) {
-    meta.exposeServices.forEach((x) => {
-      addInterface({
-        type: 'service',
-        name: x.protocol,
-        protocol: x.protocol,
-        port: {
-          internal: `BLOCKLET_${x.protocol}_PORT`.toUpperCase(),
-          external: x.port,
-        },
-      });
-    });
-  }
-
-  if (removeMerged) {
-    delete meta.publicUrl;
-    delete meta.adminUrl;
-    delete meta.configUrl;
-    delete meta.docUrl;
-    delete meta.exposeServices;
-    if (meta.capabilities) {
-      delete meta.capabilities.dynamicPathPrefix;
-    }
-  }
-
-  return meta;
 };
-
-module.exports = {
-  fixRequired,
-  fixRepository,
-  fixFiles,
-  fixKeywords,
-  fixPerson,
-  fixTags,
-  formatPerson,
-  parsePerson,
-  fixInterfaces,
-  fixService: fixAndValidateService,
+exports.fixInterfaces = fixInterfaces;
+exports.default = {
+    fixRequired,
+    fixRepository,
+    fixFiles,
+    fixKeywords,
+    fixPerson,
+    fixTags,
+    formatPerson,
+    parsePerson,
+    fixInterfaces,
+    fixService: validate_1.fixAndValidateService,
 };

package/lib/get-component-process-id.d.ts

@@ -0,0 +1,5 @@
+import { TBlockletMeta } from './types';
+declare const getComponentProcessId: (component: {
+    meta: TBlockletMeta;
+}, ancestors?: any[]) => string;
+export = getComponentProcessId;

package/lib/get-component-process-id.js

@@ -1,17 +1,16 @@
-const crypto = require('crypto');
-
-const md5 = (str) => crypto.createHash('md5').update(str).digest('hex');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const crypto_1 = __importDefault(require("crypto"));
+const md5 = (str) => crypto_1.default.createHash('md5').update(str).digest('hex');
 const getComponentProcessId = (component, ancestors = []) => {
-  const name = !ancestors.length
-    ? component.meta.name
-    : `${ancestors.map((x) => encodeURIComponent(x.meta.name)).join('/')}/${encodeURIComponent(component.meta.name)}`;
-
-  if (name.length < 240) {
-    return name;
-  }
-
-  return md5(name);
+    const name = !ancestors.length
+        ? component.meta.name
+        : `${ancestors.map((x) => encodeURIComponent(x.meta.name)).join('/')}/${encodeURIComponent(component.meta.name)}`;
+    if (name.length < 240) {
+        return name;
+    }
+    return md5(name);
 };
-
 module.exports = getComponentProcessId;

package/lib/has-reserved-key.d.ts

@@ -0,0 +1,3 @@
+import { TEnvironment } from './types';
+declare const hasReservedKey: (environments: TEnvironment[]) => boolean;
+export = hasReservedKey;

package/lib/has-reserved-key.js

@@ -1,14 +1,15 @@
-const { BLOCKLET_CONFIGURABLE_KEY } = require('./constants');
-
-const hasReservedKey = (environments) =>
-  environments.some((x) => {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const constants_1 = __importDefault(require("./constants"));
+const { BLOCKLET_CONFIGURABLE_KEY } = constants_1.default;
+const hasReservedKey = (environments) => environments.some((x) => {
+    // @ts-ignore
     const key = (x.key || x.name || '').toString();
-
     if (key.startsWith('ABT_NODE_')) {
-      return true;
+        return true;
     }
-
     return !!(key.startsWith('BLOCKLET_') && !BLOCKLET_CONFIGURABLE_KEY[key]);
-  });
-
+});
 module.exports = hasReservedKey;

package/lib/index.d.ts

@@ -0,0 +1,82 @@
+/// <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 } from './fix';
+import { list, select, update } from './file';
+import verifyMultiSig from './verify-multi-sig';
+export { constants };
+export { list };
+export { select };
+export { update };
+export { parse };
+export { validateMeta };
+export { fixAndValidateService };
+export { formatPerson };
+export { parsePerson };
+export { fixPerson };
+export { fixInterfaces };
+export { fixService };
+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;
+    parse: (dir: string, { ensureMain, ensureFiles, ensureDist, extraRawAttrs, serviceMetas, schemaOptions, fix, }?: {
+        ensureMain?: boolean;
+        ensureFiles?: boolean;
+        ensureDist?: boolean;
+        extraRawAttrs?: any;
+        serviceMetas?: any;
+        schemaOptions?: any;
+        enableDefaults?: boolean;
+        extraAttrSpec?: any;
+        fix?: boolean;
+    }) => import("./types").TBlockletMeta;
+    validateMeta: (meta: any, { ensureMain, ensureFiles, ensureDist, schemaOptions, }?: {
+        ensureMain?: boolean;
+        ensureFiles?: boolean;
+        ensureDist?: 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;
+    fixService: (meta: import("./types").TBlockletMeta) => import("./types").TBlockletMeta;
+    toBlockletDid: {
+        (name: string | Buffer): string;
+        toExternalBlocklet(name: string, userDid: string, { didOnly, nameOnly }?: {
+            didOnly?: boolean;
+            nameOnly?: boolean;
+        }): string | Pick<import("./types").TBlockletMeta, "name" | "did">;
+    };
+    getBlockletWallet: (blockletDid: string, nodeSk?: string, type?: 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;
+        description: string;
+        passportColor?: string;
+        appUrl: string;
+        wallet?: import("@ocap/wallet").WalletObject<string>;
+    };
+    getBlockletEngine: (meta: import("./types").TBlockletMeta) => import("./types").TEngine;
+    verifyMultiSig: (blockletMeta: import("./types").TBlockletMeta) => boolean;
+};
+export default _default;