@blocklet/meta 1.15.17 → 1.16.0-beta-b16cb035

package/lib/channel.d.ts

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

package/lib/channel.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChannel = exports.getRelayChannelRegex = exports.getRelayChannel = 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 getRelayChannelRegex = () => /relay:(\w+):(\w+)/;
+exports.getRelayChannelRegex = getRelayChannelRegex;
+const getAppPublicChannel = (appDid) => `app:${appDid}:public`;
+exports.getAppPublicChannel = getAppPublicChannel;
+const getRelayChannel = (appDid, topic) => `relay:${appDid}:${topic}`;
+exports.getRelayChannel = getRelayChannel;
+const CHANNEL_TYPE = {
+    DID: 'DID',
+    APP: 'APP',
+    RELAY: 'RELAY',
+};
+exports.CHANNEL_TYPE = CHANNEL_TYPE;
+const parseChannel = (channel) => {
+    if (!channel) {
+        throw new Error('Channel should not be empty');
+    }
+    let match = getRelayChannelRegex().exec(channel);
+    if (match && (0, did_1.isValid)(match[1])) {
+        return {
+            type: CHANNEL_TYPE.RELAY,
+            appDid: match[1],
+            topic: match[2],
+        };
+    }
+    match = getAppPublicChannelRegex().exec(channel);
+    if (match && (0, did_1.isValid)(match[1])) {
+        return {
+            type: CHANNEL_TYPE.APP,
+            appDid: match[1],
+        };
+    }
+    if ((0, did_1.isValid)(channel)) {
+        return {
+            type: CHANNEL_TYPE.DID,
+        };
+    }
+    throw new Error(`Invalid channel format: ${channel}`);
+};
+exports.parseChannel = parseChannel;
+exports.default = {
+    CHANNEL_TYPE,
+    getAppPublicChannel,
+    getAppPublicChannelRegex,
+    getRelayChannel,
+    getRelayChannelRegex,
+    parseChannel,
+};

package/lib/constants.d.ts

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

package/lib/constants.js

@@ -1,153 +1,6 @@
-const BLOCKLET_INTERFACE_TYPE_WEB = 'web';
-const BLOCKLET_INTERFACE_TYPE_SERVICE = 'service';
-
-// Wellknown interface declares an sub-interface under web interface
-// The path of the wellknown interface must starts with /.well-known, e.g. /.well-known/acme-challenge)
-// The wellknown interface can be mounted to every endpoint of the abtnode and all blocklets on the abtnode
-const BLOCKLET_INTERFACE_TYPE_WELLKNOWN = 'wellknown';
-
-const BlockletStatus = Object.freeze({
-  added: 0,
-  downloading: 1,
-  downloaded: 2, // Deprecated
-  installing: 3,
-  installed: 4,
-  starting: 5,
-  running: 6,
-  stopping: 7,
-  stopped: 8,
-  error: 9,
-  upgrading: 10,
-  restarting: 11, // Deprecated
-  corrupted: 12,
-  waiting: 13,
-});
-
-const BlockletSource = Object.freeze({
-  registry: 0,
-  local: 1,
-  upload: 2,
-  url: 3,
-});
-
-const BlockletEvents = Object.freeze({
-  added: 'blocklet.added',
-  downloadFailed: 'blocklet.downloadFailed',
-  installed: 'blocklet.installed',
-  installFailed: 'blocklet.installFailed',
-  upgraded: 'blocklet.upgraded',
-  downgraded: 'blocklet.downgraded',
-  deployed: 'blocklet.deployed',
-  updated: 'blocklet.updated',
-  statusChange: 'blocklet.statusChange',
-  removed: 'blocklet.removed',
-  started: 'blocklet.started',
-  startFailed: 'blocklet.startFailed',
-  stopped: 'blocklet.stopped',
-  reloaded: 'blocklet.reloaded', // Deprecated
-  purchaseChange: 'blocklet.purchaseChange',
-});
-
-const fromEntry = (entries) => (v) => {
-  const match = Object.entries(entries).find((x) => x[1] === Number(v));
-  return match ? match[0] : 'unknown';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
-const toEntry = (entries) => (v) => Object.keys(entries).find((x) => entries[x] === Number(v));
-
-const fromBlockletStatus = fromEntry(BlockletStatus);
-const toBlockletStatus = toEntry(BlockletStatus);
-
-const fromBlockletSource = fromEntry(BlockletSource);
-const toBlockletSource = toEntry(BlockletSource);
-
-const BLOCKLET_INTERFACE_PUBLIC = 'publicUrl';
-const BLOCKLET_INTERFACE_ADMIN = 'adminUrl';
-const BLOCKLET_INTERFACE_CONFIG = 'configUrl';
-const BLOCKLET_INTERFACE_DOC = 'docUrl';
-const BLOCKLET_INTERFACE_WELLKNOWN = 'wellknownUrl'; // Deprecated
-
-module.exports = Object.freeze({
-  BlockletStatus,
-  BlockletSource,
-  fromBlockletStatus,
-  toBlockletStatus,
-  fromBlockletSource,
-  toBlockletSource,
-
-  BlockletGroup: Object.freeze({
-    static: 'static',
-    dapp: 'dapp',
-    starter: false,
-    gateway: 'gateway',
-  }),
-  BLOCKLET_GROUPS: ['dapp', 'static', 'gateway'],
-
-  BlockletEvents,
-
-  BLOCKLET_PLATFORMS: ['aix', 'darwin', 'freebsd', 'linux', 'openbsd', 'sunos', 'win32'],
-  BLOCKLET_ARCHITECTURES: ['arm', 'arm64', 'ia32', 'mips', 'mipsel', 'ppc', 'ppc64', 's390', 's390x', 'x32', 'x64'],
-  BLOCKLET_MODES: Object.freeze({
-    PRODUCTION: 'production',
-    DEVELOPMENT: 'development',
-  }),
-
-  BLOCKLET_FACTORY_SHARES: { developer: 0.7, store: 0.3 },
-
-  BLOCKLET_DYNAMIC_PATH_PREFIX: '*',
-
-  BLOCKLET_INTERFACE_PUBLIC,
-  BLOCKLET_INTERFACE_ADMIN,
-  BLOCKLET_INTERFACE_CONFIG,
-  BLOCKLET_INTERFACE_DOC,
-  BLOCKLET_INTERFACE_WELLKNOWN,
-
-  BLOCKLET_UI_INTERFACES: [
-    BLOCKLET_INTERFACE_PUBLIC,
-    BLOCKLET_INTERFACE_ADMIN,
-    BLOCKLET_INTERFACE_CONFIG,
-    BLOCKLET_INTERFACE_DOC,
-  ],
-
-  BLOCKLET_STANDARD_INTERFACES: [
-    BLOCKLET_INTERFACE_PUBLIC,
-    BLOCKLET_INTERFACE_ADMIN,
-    BLOCKLET_INTERFACE_CONFIG,
-    BLOCKLET_INTERFACE_DOC,
-    BLOCKLET_INTERFACE_WELLKNOWN,
-  ],
-
-  BLOCKLET_INTERFACE_TYPE_WEB,
-  BLOCKLET_INTERFACE_TYPE_SERVICE,
-  BLOCKLET_INTERFACE_TYPE_WELLKNOWN,
-  BLOCKLET_INTERFACE_TYPES: [
-    BLOCKLET_INTERFACE_TYPE_WEB,
-    BLOCKLET_INTERFACE_TYPE_SERVICE,
-    BLOCKLET_INTERFACE_TYPE_WELLKNOWN,
-  ],
-
-  BLOCKLET_INTERFACE_PROTOCOLS: ['tcp', 'udp', 'http'],
-
-  BLOCKLET_RELEASE_FOLDER: '.blocklet/release',
-  BLOCKLET_RELEASE_FILE: 'blocklet.json',
-  BLOCKLET_BUNDLE_FOLDER: '.blocklet/bundle',
-  BLOCKLET_BUNDLE_FILE: 'blocklet.zip',
-  BLOCKLET_ENTRY_FILE: 'blocklet.js',
-  BLOCKLET_META_FILE: 'blocklet.yml',
-  BLOCKLET_META_FILE_ALT: 'blocklet.yaml',
-  BLOCKLET_META_FILE_OLD: 'blocklet.json',
-
-  BLOCKLET_DEFAULT_VERSION: '1.0.0',
-  BLOCKLET_DEFAULT_PORT_NAME: 'BLOCKLET_PORT',
-
-  BLOCKLET_LATEST_SPEC_VERSION: '1.1.1',
-  BLOCKLET_LATEST_REQUIREMENT_ABTNODE: '>=1.2.0',
-
-  BLOCKLET_CONFIGURABLE_KEY: {
-    BLOCKLET_CLUSTER_SIZE: 'BLOCKLET_CLUSTER_SIZE',
-    BLOCKLET_APP_NAME: 'BLOCKLET_APP_NAME',
-    BLOCKLET_APP_DESCRIPTION: 'BLOCKLET_APP_DESCRIPTION',
-    BLOCKLET_APP_SK: 'BLOCKLET_APP_SK',
-    BLOCKLET_WALLET_TYPE: 'BLOCKLET_WALLET_TYPE',
-  },
-});
+const constant_1 = __importDefault(require("@blocklet/constant"));
+module.exports = constant_1.default;

package/lib/did.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+declare const toBlockletDid: (name: string | Buffer) => string;
+export = toBlockletDid;

package/lib/did.js

@@ -1,12 +1,12 @@
-const Mcrypto = require('@ocap/mcrypto');
-const { toHex } = require('@ocap/util');
-const { fromPublicKey } = require('@arcblock/did');
-
-const { types } = Mcrypto;
-
+"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(name);
-  return fromPublicKey(pk, { role: types.RoleType.ROLE_ANY });
+    if ((0, did_1.isValid)(name)) {
+        return name;
+    }
+    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 });
 };
-
 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(`${meta.bundleName} 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(`${meta.bundleName} 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(`${meta.bundleName} 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(`${meta.bundleName} 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(`${meta.bundleName} 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(`${meta.bundleName} Unsupported blocklet type ${group}`);
 };
+module.exports = validateBlockletEntry;

package/lib/extension.d.ts

@@ -0,0 +1,14 @@
+import { Extension, Root } from 'joi';
+declare const fileExtension: (joi: Root) => Extension;
+/**
+ * joi extend did 判断
+ * 由于需要兼容新旧两种 did 模式判断，所以这里不能做 role 类型判断
+ */
+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,88 @@
-/* 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 = () => false } = {}) {
+                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;
+/**
+ * joi extend did 判断
+ * 由于需要兼容新旧两种 did 模式判断，所以这里不能做 role 类型判断
+ */
 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,23 @@
+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;
+declare const read: (file: string) => unknown;
+export { list };
+export { read };
+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;