@blocklet/meta 1.8.34 → 1.8.35

package/lib/channel.d.ts

@@ -0,0 +1,27 @@
+declare const getAppPublicChannelRegex: () => RegExp;
+declare const getAppPublicChannel: (appDid: string) => string;
+declare const CHANNEL_TYPE: {
+    DID: string;
+    APP: string;
+};
+declare const parseChannel: (channel: string) => {
+    type: string;
+    appDid?: string;
+};
+export { CHANNEL_TYPE };
+export { getAppPublicChannel };
+export { getAppPublicChannelRegex };
+export { parseChannel };
+declare const _default: {
+    CHANNEL_TYPE: {
+        DID: string;
+        APP: string;
+    };
+    getAppPublicChannel: (appDid: string) => string;
+    getAppPublicChannelRegex: () => RegExp;
+    parseChannel: (channel: string) => {
+        type: string;
+        appDid?: string;
+    };
+};
+export default _default;

package/lib/channel.js

@@ -1,39 +1,39 @@
-const { isValid: isValidDid } = require('@arcblock/did');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChannel = exports.getAppPublicChannelRegex = exports.getAppPublicChannel = exports.CHANNEL_TYPE = void 0;
+/* eslint-disable @typescript-eslint/indent */
+const did_1 = require("@arcblock/did");
 const getAppPublicChannelRegex = () => /app:(\w+):public/;
-
+exports.getAppPublicChannelRegex = getAppPublicChannelRegex;
 const getAppPublicChannel = (appDid) => `app:${appDid}:public`;
-
+exports.getAppPublicChannel = getAppPublicChannel;
 const CHANNEL_TYPE = {
-  DID: 'DID',
-  APP: 'APP',
+    DID: 'DID',
+    APP: 'APP',
 };
-
+exports.CHANNEL_TYPE = CHANNEL_TYPE;
 const parseChannel = (channel) => {
-  if (!channel) {
-    throw new Error('Channel should not be empty');
-  }
-
-  const matchAppPublicChannel = getAppPublicChannelRegex().exec(channel);
-  if (matchAppPublicChannel) {
-    return {
-      type: CHANNEL_TYPE.APP,
-      appDid: matchAppPublicChannel[1],
-    };
-  }
-
-  if (isValidDid(channel)) {
-    return {
-      type: CHANNEL_TYPE.DID,
-    };
-  }
-
-  throw new Error(`Invalid channel format: ${channel}`);
+    if (!channel) {
+        throw new Error('Channel should not be empty');
+    }
+    const matchAppPublicChannel = getAppPublicChannelRegex().exec(channel);
+    if (matchAppPublicChannel) {
+        return {
+            type: CHANNEL_TYPE.APP,
+            appDid: matchAppPublicChannel[1],
+        };
+    }
+    if ((0, did_1.isValid)(channel)) {
+        return {
+            type: CHANNEL_TYPE.DID,
+        };
+    }
+    throw new Error(`Invalid channel format: ${channel}`);
 };
-
-module.exports = {
-  CHANNEL_TYPE,
-  getAppPublicChannel,
-  getAppPublicChannelRegex,
-  parseChannel,
+exports.parseChannel = parseChannel;
+exports.default = {
+    CHANNEL_TYPE,
+    getAppPublicChannel,
+    getAppPublicChannelRegex,
+    parseChannel,
 };

package/lib/constants.d.ts

@@ -0,0 +1,2 @@
+import constant from '@blocklet/constant';
+export = constant;

package/lib/constants.js

@@ -1,3 +1,6 @@
-const constant = require('@blocklet/constant');
-
-module.exports = constant;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const constant_1 = __importDefault(require("@blocklet/constant"));
+module.exports = constant_1.default;

package/lib/did.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { TBlockletMeta } from './types';
+declare const toBlockletDid: {
+    (name: string | Buffer): string;
+    toExternalBlocklet(name: string, userDid: string, { didOnly, nameOnly }?: {
+        didOnly?: boolean;
+        nameOnly?: boolean;
+    }): Pick<TBlockletMeta, 'did' | 'name'> | string;
+};
+export = toBlockletDid;

package/lib/did.js

@@ -1,29 +1,23 @@
-const { types } = require('@ocap/mcrypto');
-const { toHex } = require('@ocap/util');
-const { fromPublicKey } = require('@arcblock/did');
-
+"use strict";
+const mcrypto_1 = require("@ocap/mcrypto");
+const util_1 = require("@ocap/util");
+const did_1 = require("@arcblock/did");
 const toBlockletDid = (name) => {
-  const pk = toHex(Buffer.from(typeof name === 'string' ? name.trim() : name));
-  return fromPublicKey(pk, { role: types.RoleType.ROLE_ANY });
+    const pk = (0, util_1.toHex)(Buffer.from(typeof name === 'string' ? name.trim() : name));
+    return (0, did_1.fromPublicKey)(pk, { role: mcrypto_1.types.RoleType.ROLE_ANY });
 };
-
 toBlockletDid.toExternalBlocklet = (name, userDid, { didOnly, nameOnly } = {}) => {
-  const blockletName = `${name}-${userDid.toLowerCase().substring(userDid.length - 6)}`;
-
-  if (nameOnly) {
-    return blockletName;
-  }
-
-  const blockletDid = toBlockletDid(blockletName);
-
-  if (didOnly) {
-    return blockletDid;
-  }
-
-  return {
-    name: blockletName,
-    did: blockletDid,
-  };
+    const blockletName = `${name}-${userDid.toLowerCase().substring(userDid.length - 6)}`;
+    if (nameOnly) {
+        return blockletName;
+    }
+    const blockletDid = toBlockletDid(blockletName);
+    if (didOnly) {
+        return blockletDid;
+    }
+    return {
+        name: blockletName,
+        did: blockletDid,
+    };
 };
-
 module.exports = toBlockletDid;

package/lib/engine.d.ts

@@ -0,0 +1,7 @@
+import { TBlockletMeta, TEngine } from './types';
+/**
+ * get blocklet engine info by platform
+ * @param {object} meta blocklet meta
+ */
+declare const getEngineByPlatform: (meta: TBlockletMeta) => TEngine;
+export = getEngineByPlatform;

package/lib/engine.js

@@ -1,32 +1,28 @@
-const os = require('os');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const os_1 = __importDefault(require("os"));
 /**
  * get blocklet engine info by platform
  * @param {object} meta blocklet meta
  */
 const getEngineByPlatform = (meta) => {
-  if (meta === undefined) {
-    throw new Error('blocklet meta param is required');
-  }
-
-  const { engine } = meta;
-
-  if (!engine) {
-    return { interpreter: 'node' };
-  }
-
-  if (!Array.isArray(engine)) {
-    return engine;
-  }
-
-  const platform = os.platform();
-
-  const tmpRuntime = engine.find((r) => r.platform === platform);
-  if (!tmpRuntime) {
-    throw new Error(`can not find a proper engine interpreter on ${platform}`);
-  }
-
-  return tmpRuntime;
+    if (meta === undefined) {
+        throw new Error('blocklet meta param is required');
+    }
+    const { engine } = meta;
+    if (!engine) {
+        return { interpreter: 'node', script: '' };
+    }
+    if (!Array.isArray(engine)) {
+        return engine;
+    }
+    const platform = os_1.default.platform();
+    const tmpRuntime = engine.find((r) => r.platform === platform);
+    if (!tmpRuntime) {
+        throw new Error(`can not find a proper engine interpreter on ${platform}`);
+    }
+    return tmpRuntime;
 };
-
 module.exports = getEngineByPlatform;

package/lib/entry.d.ts

@@ -0,0 +1,3 @@
+import { TBlockletMeta } from './types';
+declare const validateBlockletEntry: (dir: string, meta: TBlockletMeta) => void;
+export = validateBlockletEntry;

package/lib/entry.js

@@ -1,69 +1,56 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const isEmpty = require('lodash/isEmpty');
-const get = require('lodash/get');
-
-const { BLOCKLET_BUNDLE_FOLDER, BlockletGroup } = require('./constants');
-
-/**
- * check if blocklet entry file/folder exist
- *
- * @param {string} dir
- * @param {object} meta
- */
-module.exports = (dir, meta) => {
-  const { main, group } = meta;
-  if (group === BlockletGroup.dapp) {
-    // backward compatible
-    if (
-      !fs.existsSync(path.join(dir, 'blocklet.js')) &&
-      !fs.existsSync(path.join(dir, BLOCKLET_BUNDLE_FOLDER, 'blocklet.js'))
-    ) {
-      // backward compatible
-      if (isEmpty(meta.engine)) {
-        throw new Error('DApp blocklet may be corrupted or not properly bundled: missing blocklet.js');
-      }
-
-      const engine = get(meta, 'engine', null);
-      if (engine) {
-        if (!Array.isArray(engine)) {
-          if (!engine.interpreter) {
-            throw new Error('DApp blocklet may be corrupted or not properly configured: missing engine.interpreter');
-          }
-
-          return;
-        }
-
-        engine.forEach((r) => {
-          ['interpreter', 'platform'].forEach((k) => {
-            if (!get(r, k, null)) {
-              throw new Error(`DApp blocklet may be corrupted or not properly configured: missing engine.${k}`);
+"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 os_1 = __importDefault(require("os"));
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+const get_1 = __importDefault(require("lodash/get"));
+const constants_1 = __importDefault(require("./constants"));
+const { BLOCKLET_BUNDLE_FOLDER, BlockletGroup } = constants_1.default;
+const validateBlockletEntry = (dir, meta) => {
+    const { main, group } = meta;
+    if (group === BlockletGroup.dapp) {
+        // backward compatible
+        if (!fs_1.default.existsSync(path_1.default.join(dir, 'blocklet.js')) &&
+            !fs_1.default.existsSync(path_1.default.join(dir, BLOCKLET_BUNDLE_FOLDER, 'blocklet.js'))) {
+            // backward compatible
+            if ((0, isEmpty_1.default)(meta.engine)) {
+                throw new Error('DApp blocklet may be corrupted or not properly bundled: missing blocklet.js');
+            }
+            const engine = (0, get_1.default)(meta, 'engine', null);
+            if (engine) {
+                if (!Array.isArray(engine)) {
+                    if (!engine.interpreter) {
+                        throw new Error('DApp blocklet may be corrupted or not properly configured: missing engine.interpreter');
+                    }
+                    return;
+                }
+                engine.forEach((r) => {
+                    ['interpreter', 'platform'].forEach((k) => {
+                        if (!(0, get_1.default)(r, k, null)) {
+                            throw new Error(`DApp blocklet may be corrupted or not properly configured: missing engine.${k}`);
+                        }
+                    });
+                });
+                const platform = os_1.default.platform();
+                if (!engine.find((r) => r.platform === platform)) {
+                    throw new Error(`DApp blocklet may be corrupted or not properly configured: no engine run on ${platform}`);
+                }
             }
-          });
-        });
-
-        const platform = os.platform();
-
-        if (!engine.find((r) => r.platform === platform)) {
-          throw new Error(`DApp blocklet may be corrupted or not properly configured: no engine run on ${platform}`);
         }
-      }
+        return;
+    }
+    if (group === BlockletGroup.static) {
+        if (!fs_1.default.existsSync(path_1.default.join(dir, main))) {
+            throw new Error('Static blocklet may be corrupted or not properly configured: missing main folder');
+        }
+        return;
     }
-
-    return;
-  }
-
-  if (group === BlockletGroup.static) {
-    if (!fs.existsSync(path.join(dir, main))) {
-      throw new Error('Static blocklet may be corrupted or not properly configured: missing main folder');
+    if (group === BlockletGroup.gateway) {
+        return;
     }
-    return;
-  }
-
-  if (group === BlockletGroup.gateway) {
-    return;
-  }
-
-  throw new Error(`Unsupported blocklet type ${group}`);
+    throw new Error(`Unsupported blocklet type ${group}`);
 };
+module.exports = validateBlockletEntry;

package/lib/extension.d.ts

@@ -0,0 +1,10 @@
+import { Extension, Root } from 'joi';
+declare const fileExtension: (joi: Root) => Extension;
+declare const didExtension: (joi: Root) => Extension;
+export { fileExtension };
+export { didExtension };
+declare const _default: {
+    fileExtension: (joi: Root) => Extension;
+    didExtension: (joi: Root) => Extension;
+};
+export default _default;

package/lib/extension.js

@@ -1,83 +1,84 @@
-/* eslint-disable default-case */
-/* eslint-disable indent */
-const fs = require('fs');
-const path = require('path');
-const { isValid } = require('@arcblock/did');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.didExtension = exports.fileExtension = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const did_1 = require("@arcblock/did");
 const fileExtension = (joi) => ({
-  type: 'file',
-  base: joi.string(),
-  validate(value, { error }) {
-    if (value && typeof value === 'string') {
-      return { value };
-    }
-
-    return { errors: error('file.empty', { file: value }) };
-  },
-  messages: {
-    'file.empty': 'file "{{#file}}" must be non-empty string',
-    'file.enoent': 'file "{{#file}}" does not exist',
-    'file.error.generic': 'file could not be read. message: "{{#message}}"',
-  },
-
-  rules: {
-    exists: {
-      multi: false,
-      method({ baseDir = null, canSkip } = {}) {
-        return this.$_addRule({ name: 'exists', args: { baseDir, canSkip } });
-      },
-      args: [
-        {
-          name: 'baseDir',
-          assert: (baseDir) => fs.existsSync(baseDir),
-          message: 'baseDir must exist',
-        },
-        {
-          name: 'canSkip',
-          assert: (canSkip) => typeof canSkip === 'function',
-          message: 'canSkip must be a function',
-        },
-      ],
-
-      validate(value, { error }, { baseDir, canSkip } = {}) {
-        if (typeof canSkip === 'function' && canSkip(baseDir, value)) {
-          return value;
-        }
-
-        try {
-          fs.statSync(path.join(baseDir, value));
-          return value;
-        } catch (e) {
-          switch (e.code) {
-            case 'ENOENT':
-              return error('file.enoent', { file: value });
-          }
-
-          return error('file.error.generic', { message: e.message });
+    type: 'file',
+    base: joi.string(),
+    validate(value, { error }) {
+        if (value && typeof value === 'string') {
+            return { value };
         }
-      },
+        return { errors: error('file.empty', { file: value }) };
+    },
+    messages: {
+        'file.empty': 'file "{{#file}}" must be non-empty string',
+        'file.enoent': 'file "{{#file}}" does not exist',
+        'file.error.generic': 'file could not be read. message: "{{#message}}"',
+    },
+    rules: {
+        exists: {
+            multi: false,
+            method({ baseDir = null, canSkip } = {}) {
+                return this.$_addRule({ name: 'exists', args: { baseDir, canSkip } });
+            },
+            args: [
+                {
+                    name: 'baseDir',
+                    assert: (baseDir) => fs_1.default.existsSync(baseDir),
+                    message: 'baseDir must exist',
+                },
+                {
+                    name: 'canSkip',
+                    assert: (canSkip) => typeof canSkip === 'function',
+                    message: 'canSkip must be a function',
+                },
+            ],
+            validate(value, { error }, { baseDir, canSkip } = {}) {
+                if (typeof canSkip === 'function' && canSkip(baseDir, value)) {
+                    return value;
+                }
+                try {
+                    fs_1.default.statSync(path_1.default.join(baseDir, value));
+                    return value;
+                }
+                catch (e) {
+                    switch (e.code) {
+                        case 'ENOENT':
+                            return error('file.enoent', { file: value });
+                        default:
+                    }
+                    return error('file.error.generic', { message: e.message });
+                }
+            },
+        },
     },
-  },
 });
-
+exports.fileExtension = fileExtension;
 const didExtension = (joi) => ({
-  type: 'DID',
-  base: joi.string(),
-  validate(value, { error }) {
-    if (!value || typeof value !== 'string') {
-      return { errors: error('did.empty', { did: value }) };
-    }
-
-    if (isValid(value) === false) {
-      return { errors: error('did.invalid', { did: value }) };
-    }
-
-    return { value };
-  },
-  messages: {
-    'did.empty': 'did "{{#did}}" must be non-empty string',
-    'did.invalid': 'did "{{#did}}" is not valid',
-  },
+    type: 'DID',
+    base: joi.string(),
+    validate(value, { error }) {
+        if (!value || typeof value !== 'string') {
+            return { errors: error('did.empty', { did: value }) };
+        }
+        if ((0, did_1.isValid)(value) === false) {
+            return { errors: error('did.invalid', { did: value }) };
+        }
+        return { value };
+    },
+    messages: {
+        'did.empty': 'did "{{#did}}" must be non-empty string',
+        'did.invalid': 'did "{{#did}}" is not valid',
+    },
 });
-
-module.exports = { fileExtension, didExtension };
+exports.didExtension = didExtension;
+exports.default = {
+    fileExtension,
+    didExtension,
+};

package/lib/file.d.ts

@@ -0,0 +1,21 @@
+import { TBlockletMeta } from './types';
+declare const list: any[];
+declare const select: (dir: string, { throwOnError }?: {
+    throwOnError?: boolean;
+}) => string;
+declare const update: (file: string, meta: TBlockletMeta, { fix }?: {
+    fix?: boolean;
+}) => void;
+export { list };
+export { select };
+export { update };
+declare const _default: {
+    list: any[];
+    select: (dir: string, { throwOnError }?: {
+        throwOnError?: boolean;
+    }) => string;
+    update: (file: string, meta: TBlockletMeta, { fix }?: {
+        fix?: boolean;
+    }) => void;
+};
+export default _default;

package/lib/file.js

@@ -1,45 +1,50 @@
-const path = require('path');
-const yaml = require('js-yaml');
-const fs = require('fs-extra');
-const { BLOCKLET_META_FILE, BLOCKLET_META_FILE_ALT } = require('./constants');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = exports.select = exports.list = void 0;
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const constants_1 = __importDefault(require("./constants"));
+const { BLOCKLET_META_FILE, BLOCKLET_META_FILE_ALT } = constants_1.default;
 const list = [BLOCKLET_META_FILE, BLOCKLET_META_FILE_ALT];
-
+exports.list = list;
 const select = (dir, { throwOnError = true } = {}) => {
-  const metaFile = path.join(dir, BLOCKLET_META_FILE);
-  const metaFileAlt = path.join(dir, BLOCKLET_META_FILE_ALT);
-
-  if (fs.existsSync(metaFile) === false && fs.existsSync(metaFileAlt) === false) {
-    if (throwOnError) {
-      throw new Error('blocklet.yml not found, please migrate your blocklet meta by run `abtnode blocklet:migrate`');
+    const metaFile = path_1.default.join(dir, BLOCKLET_META_FILE);
+    const metaFileAlt = path_1.default.join(dir, BLOCKLET_META_FILE_ALT);
+    if (fs_extra_1.default.existsSync(metaFile) === false && fs_extra_1.default.existsSync(metaFileAlt) === false) {
+        if (throwOnError) {
+            throw new Error('blocklet.yml not found, please migrate your blocklet meta by run `abtnode blocklet:migrate`');
+        }
+        return '';
     }
-
-    return '';
-  }
-
-  const metaToUpdate = fs.existsSync(metaFile) ? metaFile : fs.existsSync(metaFileAlt) ? metaFileAlt : null; // eslint-disable-line
-  return metaToUpdate;
+    const metaToUpdate = fs_extra_1.default.existsSync(metaFile) ? metaFile : fs_extra_1.default.existsSync(metaFileAlt) ? metaFileAlt : null; // eslint-disable-line
+    return metaToUpdate;
 };
-
+exports.select = select;
 const update = (file, meta, { fix = true } = {}) => {
-  if (!fix) {
-    fs.writeFileSync(file, yaml.dump(meta, { sortKeys: false, skipInvalid: true }));
-    return;
-  }
-
-  delete meta.path;
-  delete meta.folder;
-  delete meta.htmlAst;
-  delete meta.stats;
-  delete meta.nftFactory;
-  delete meta.signatures;
-  delete meta.lastPublishedAt;
-
-  if (!meta.specVersion) {
-    meta.specVersion = '1.0.0';
-  }
-
-  fs.writeFileSync(file, yaml.dump(meta, { sortKeys: false, skipInvalid: true }));
+    if (!fix) {
+        fs_extra_1.default.writeFileSync(file, js_yaml_1.default.dump(meta, { sortKeys: false, skipInvalid: true }));
+        return;
+    }
+    delete meta.path;
+    // @ts-ignore
+    delete meta.folder;
+    delete meta.htmlAst;
+    delete meta.stats;
+    delete meta.nftFactory;
+    delete meta.signatures;
+    delete meta.lastPublishedAt;
+    if (!meta.specVersion) {
+        meta.specVersion = '1.0.0';
+    }
+    fs_extra_1.default.writeFileSync(file, js_yaml_1.default.dump(meta, { sortKeys: false, skipInvalid: true }));
+};
+exports.update = update;
+exports.default = {
+    list,
+    select,
+    update,
 };
-
-module.exports = { list, select, update };