@blocklet/meta 1.8.34 → 1.8.36

package/lib/service-configs/auth.json

@@ -1,66 +1,66 @@
 {
-  "name": "auth",
-  "description": "Neat and easy to use user authentication and authorization service for blocklets",
-  "version": "1.0.0",
-  "schema": {
-    "JSONSchema": {
-      "title": "Config Auth Service",
-      "description": "Customize how Auth Service works",
-      "type": "object",
-      "required": ["profileFields", "webWalletUrl"],
-      "properties": {
-        "whoCanAccess": {
-          "type": "string",
-          "title": "Who can access the blocklet?",
-          "enum": ["owner", "invited", "all"],
-          "default": "all"
+    "name": "auth",
+    "description": "Neat and easy to use user authentication and authorization service for blocklets",
+    "version": "1.0.0",
+    "schema": {
+        "JSONSchema": {
+            "title": "Config Auth Service",
+            "description": "Customize how Auth Service works",
+            "type": "object",
+            "required": ["profileFields", "webWalletUrl"],
+            "properties": {
+                "whoCanAccess": {
+                    "type": "string",
+                    "title": "Who can access the blocklet?",
+                    "enum": ["owner", "invited", "all"],
+                    "default": "all"
+                },
+                "profileFields": {
+                    "type": "array",
+                    "title": "What info do you want user to provide when login?",
+                    "items": {
+                        "type": "string",
+                        "enum": ["fullName", "email", "avatar", "phone"]
+                    },
+                    "default": ["fullName", "email", "avatar"],
+                    "uniqueItems": true
+                },
+                "allowSwitchProfile": {
+                    "type": "boolean",
+                    "title": "Does you app allow user to switch profile?",
+                    "default": true
+                },
+                "webWalletUrl": {
+                    "type": "string",
+                    "title": "The URL of your preferred web wallet instance",
+                    "pattern": "^https?://",
+                    "default": "https://web.abtwallet.io"
+                },
+                "ignoreUrls": {
+                    "type": "array",
+                    "title": "Which URLs do not need to be protected. e.g: /public/**",
+                    "items": {
+                        "type": "string",
+                        "minLength": 1
+                    },
+                    "default": []
+                },
+                "blockUnauthenticated": {
+                    "type": "boolean",
+                    "title": "Do you want Auth Service block unauthenticated requests for you?",
+                    "default": false
+                },
+                "blockUnauthorized": {
+                    "type": "boolean",
+                    "title": "Do you want Auth Service block unauthorized requests for you?",
+                    "default": false
+                }
+            }
         },
-        "profileFields": {
-          "type": "array",
-          "title": "What info do you want user to provide when login?",
-          "items": {
-            "type": "string",
-            "enum": ["fullName", "email", "avatar", "phone"]
-          },
-          "default": ["fullName", "email", "avatar"],
-          "uniqueItems": true
-        },
-        "allowSwitchProfile": {
-          "type": "boolean",
-          "title": "Does you app allow user to switch profile?",
-          "default": true
-        },
-        "webWalletUrl": {
-          "type": "string",
-          "title": "The URL of your preferred web wallet instance",
-          "pattern": "^https?://",
-          "default": "https://web.abtwallet.io"
-        },
-        "ignoreUrls": {
-          "type": "array",
-          "title": "Which URLs do not need to be protected. e.g: /public/**",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          },
-          "default": []
-        },
-        "blockUnauthenticated": {
-          "type": "boolean",
-          "title": "Do you want Auth Service block unauthenticated requests for you?",
-          "default": false
-        },
-        "blockUnauthorized": {
-          "type": "boolean",
-          "title": "Do you want Auth Service block unauthorized requests for you?",
-          "default": false
+        "UISchema": {
+            "profileFields": {
+                "ui:widget": "checkboxes"
+            }
         }
-      }
-    },
-    "UISchema": {
-      "profileFields": {
-        "ui:widget": "checkboxes"
-      }
     }
-  }
 }

package/lib/service.d.ts

@@ -0,0 +1,26 @@
+declare const setService: (meta: any) => void;
+declare const getServiceMetas: ({ stringifySchema }?: {
+    stringifySchema?: boolean;
+}) => any[];
+declare const getServiceConfig: (serviceName: string, customConfig: any, { validate }?: {
+    validate?: any;
+}) => any;
+declare const getDefaultServiceConfig: (serviceName: string) => any;
+declare const findService: (services: any[], name: string) => any;
+export { getServiceMetas };
+export { getServiceConfig };
+export { getDefaultServiceConfig };
+export { findService };
+export { setService };
+declare const _default: {
+    getServiceMetas: ({ stringifySchema }?: {
+        stringifySchema?: boolean;
+    }) => any[];
+    getServiceConfig: (serviceName: string, customConfig: any, { validate }?: {
+        validate?: any;
+    }) => any;
+    getDefaultServiceConfig: (serviceName: string) => any;
+    findService: (services: any[], name: string) => any;
+    setService: (meta: any) => void;
+};
+export default _default;

package/lib/service.js

@@ -1,101 +1,85 @@
-const cloneDeep = require('lodash/cloneDeep');
-const Ajv = require('ajv').default;
-
-const { NODE_SERVICES } = require('@abtnode/constant');
-
-const ajv = new Ajv({
-  useDefaults: true,
-  removeAdditional: 'all',
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setService = exports.findService = exports.getDefaultServiceConfig = exports.getServiceConfig = exports.getServiceMetas = void 0;
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const ajv_1 = __importDefault(require("ajv"));
+const constant_1 = __importDefault(require("@abtnode/constant"));
+const auth_json_1 = __importDefault(require("./service-configs/auth.json"));
+const { NODE_SERVICES } = constant_1.default;
+const ajv = new ajv_1.default({
+    useDefaults: true,
+    removeAdditional: 'all',
 });
-
 const SERVICES = {};
-
 const setService = (meta) => {
-  const validate = ajv.compile(meta.schema.JSONSchema);
-
-  // parse empty custom config to get default config
-  const defaultConfig = {};
-  validate(defaultConfig);
-
-  SERVICES[meta.name] = {
-    meta,
-    validate,
-    defaultConfig,
-  };
+    const validate = ajv.compile(meta.schema.JSONSchema);
+    // parse empty custom config to get default config
+    const defaultConfig = {};
+    validate(defaultConfig);
+    SERVICES[meta.name] = {
+        meta,
+        validate,
+        defaultConfig,
+    };
 };
-
-setService(require('./service-configs/auth.json'));
-
+exports.setService = setService;
+setService(auth_json_1.default);
 // backward compatible
-SERVICES[NODE_SERVICES.AUTH_SERVICE] = {
-  ...SERVICES[NODE_SERVICES.AUTH],
-  meta: {
-    ...SERVICES[NODE_SERVICES.AUTH].meta,
-    name: NODE_SERVICES.AUTH_SERVICE,
-  },
-};
-
+SERVICES[NODE_SERVICES.AUTH_SERVICE] = Object.assign(Object.assign({}, SERVICES[NODE_SERVICES.AUTH]), { meta: Object.assign(Object.assign({}, SERVICES[NODE_SERVICES.AUTH].meta), { name: NODE_SERVICES.AUTH_SERVICE }) });
 const getServiceMetas = ({ stringifySchema = false } = {}) => {
-  const list = Object.values(SERVICES).map(({ meta }) => {
-    const data = cloneDeep(meta);
-    if (stringifySchema) {
-      data.schema = JSON.stringify(meta.schema);
-    }
-    return data;
-  });
-
-  return list;
+    const list = Object.values(SERVICES).map(({ meta }) => {
+        const data = (0, cloneDeep_1.default)(meta);
+        if (stringifySchema) {
+            data.schema = JSON.stringify(meta.schema);
+        }
+        return data;
+    });
+    return list;
 };
-
+exports.getServiceMetas = getServiceMetas;
 const getService = (serviceName) => {
-  if (!serviceName) {
-    throw new Error('service name should not be empty');
-  }
-
-  const service = SERVICES[serviceName];
-  if (!service) {
-    throw new Error(`service ${serviceName} does not exist`);
-  }
-
-  return service;
+    if (!serviceName) {
+        throw new Error('service name should not be empty');
+    }
+    const service = SERVICES[serviceName];
+    if (!service) {
+        throw new Error(`service ${serviceName} does not exist`);
+    }
+    return service;
 };
-
 const getServiceConfig = (serviceName, customConfig, { validate } = {}) => {
-  const service = getService(serviceName);
-
-  const data = cloneDeep(customConfig || {});
-  // this method may have side effect thar will fill default value to customConfig
-  const valid = service.validate(data || {});
-
-  if (validate && !valid) {
-    const message = service.validate.errors.map((x) => `${x.instancePath} ${x.message}`).join(', ');
-    throw new Error(`Invalid blocklet service config: ${message}`);
-  }
-
-  return data;
+    const service = getService(serviceName);
+    const data = (0, cloneDeep_1.default)(customConfig || {});
+    // this method may have side effect thar will fill default value to customConfig
+    const valid = service.validate(data || {});
+    if (validate && !valid) {
+        const message = service.validate.errors.map((x) => `${x.instancePath} ${x.message}`).join(', ');
+        throw new Error(`Invalid blocklet service config: ${message}`);
+    }
+    return data;
 };
-
+exports.getServiceConfig = getServiceConfig;
 const getDefaultServiceConfig = (serviceName) => {
-  const { defaultConfig } = getService(serviceName);
-
-  return defaultConfig;
+    const { defaultConfig } = getService(serviceName);
+    return defaultConfig;
 };
-
+exports.getDefaultServiceConfig = getDefaultServiceConfig;
 const findService = (services, name) => {
-  const names = [name];
-
-  // backward compatible
-  if (name === NODE_SERVICES.AUTH) {
-    names.push(NODE_SERVICES.AUTH_SERVICE);
-  }
-
-  return (services || []).find((x) => names.includes(x.name));
+    const names = [name];
+    // backward compatible
+    if (name === NODE_SERVICES.AUTH) {
+        names.push(NODE_SERVICES.AUTH_SERVICE);
+    }
+    return (services || []).find((x) => names.includes(x.name));
 };
-
-module.exports = {
-  getServiceMetas,
-  getServiceConfig,
-  getDefaultServiceConfig,
-  findService,
-  setService,
+exports.findService = findService;
+exports.default = {
+    getServiceMetas,
+    getServiceConfig,
+    getDefaultServiceConfig,
+    findService,
+    setService,
 };

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from './schema';

package/lib/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/* eslint-disable @typescript-eslint/indent */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schema"), exports);

package/lib/types/schema.d.ts

@@ -0,0 +1,241 @@
+export interface TBlockletMeta {
+    author?: TPerson;
+    bundleDid?: string;
+    bundleName?: string;
+    capabilities?: {
+        clusterMode?: boolean;
+        component?: boolean;
+        didStorage?: 'required' | 'optional';
+    };
+    community?: string;
+    components?: TComponent[];
+    contributors?: TPerson[];
+    copyright?: {
+        owner?: string;
+        year?: string | number;
+    };
+    description: TDescription;
+    did: string;
+    dist?: TDist;
+    documentation?: string;
+    engine?: TEngine | TEngine[];
+    environments?: TEnvironment[];
+    files?: string[];
+    gitHash?: string;
+    group: 'dapp' | 'static' | 'gateway';
+    homepage?: string;
+    htmlAst?: any;
+    interfaces?: TInterface[];
+    keywords?: string | string[];
+    lastPublishedAt?: string;
+    license?: string;
+    logo?: string;
+    logoUrl?: string;
+    main: string;
+    maintainers?: TPerson[];
+    name: TBlockletName;
+    navigation?: TNavigation;
+    nftFactory?: string;
+    path?: string;
+    payment?: {
+        componentPrice?: {
+            parentPriceRange?: number[];
+            type: 'fixed' | 'percentage';
+            value: number;
+        }[];
+        price?: {
+            address: string;
+            value: number;
+        }[];
+        share?: {
+            address: string;
+            name: string;
+            value: number;
+        }[];
+    };
+    repository?: string | {
+        directory?: string;
+        type: 'git' | 'https' | 'svn';
+        url: string;
+    };
+    requirements?: {
+        abtnode?: string;
+        cpu?: '*' | 'arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | ('arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64')[];
+        fuels?: {
+            address?: string;
+            endpoint: string;
+            reason: string;
+            value: string;
+        }[];
+        nodejs?: string;
+        os?: '*' | 'aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32' | ('aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32')[];
+        server?: string;
+    };
+    screenshots?: string[];
+    scripts?: TScripts;
+    signatures?: TSignature[];
+    specVersion?: string;
+    stats?: TStats;
+    storeId?: string;
+    support?: string | string;
+    tags?: string | string[];
+    theme?: TTheme;
+    timeout?: {
+        start?: number;
+    };
+    title?: TTitle | '';
+    version: string;
+}
+export declare type TBlockletName = string;
+export interface TComponent {
+    description?: TDescription;
+    mountPoint?: TMountPoint;
+    mountPoints?: {
+        child: {
+            interfaceName: string;
+        };
+        root: {
+            interfaceName: string;
+            prefix: string;
+        };
+        services?: TService[];
+    }[];
+    name: TBlockletName;
+    resolved?: string | string;
+    services?: TService[];
+    source?: {
+        url: string | string[];
+    } | {
+        name: TBlockletName;
+        store: string | string[];
+        version?: 'latest' | string;
+    };
+    title?: TTitle;
+}
+export declare type TDescription = string;
+export interface TDist {
+    integrity: string;
+    size?: number;
+    tarball: string | string;
+}
+export interface TEndpoint {
+    meta?: {
+        params?: {
+            description: string;
+            name: string;
+        }[];
+        payable?: boolean;
+        vcType?: string;
+    };
+    path: string;
+    type: string;
+}
+export interface TEngine {
+    args?: string[];
+    interpreter?: 'binary' | 'node';
+    platform?: 'aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32';
+    script: string;
+}
+export interface TEnvironment {
+    default?: string;
+    description: string;
+    name: string;
+    required?: boolean;
+    secure?: boolean;
+    shared?: boolean;
+    validation?: string;
+}
+export interface TInterface {
+    endpoints?: TEndpoint[];
+    name: string;
+    path?: string;
+    port?: string | {
+        external: number;
+        internal: string;
+    };
+    prefix?: string;
+    protocol?: 'tcp' | 'udp' | 'http';
+    services?: TService[];
+    type: 'web' | 'service' | 'wellknown';
+}
+export declare type TLogo = string;
+export declare type TMountPoint = string;
+export declare type TNavigation = TNavigationItem[];
+export interface TNavigationItem {
+    component?: string;
+    icon?: string;
+    items?: {
+        component?: string;
+        icon?: string;
+        link?: string | {
+            en?: string;
+            zh?: string;
+        };
+        role?: string[];
+        section?: string[];
+        title: string | {
+            en?: string;
+            zh?: string;
+        };
+    }[];
+    link?: string | {
+        en?: string;
+        zh?: string;
+    };
+    role?: string[];
+    section?: string[];
+    title: string | {
+        en?: string;
+        zh?: string;
+    };
+}
+export interface TPerson {
+    email?: string;
+    name: string;
+    url?: string;
+}
+export interface TScripts {
+    dev?: string;
+    e2eDev?: string;
+    postInstall?: string;
+    postStart?: string;
+    preConfig?: string;
+    preInstall?: string;
+    preStart?: string;
+    preStop?: string;
+    preUninstall?: string;
+}
+export interface TService {
+    /**
+     * Any Property
+     */
+    [x: string]: any;
+    config?: object;
+    name: string;
+}
+export interface TSignature {
+    appended?: string[];
+    created: string;
+    delegatee?: string;
+    delegateePk?: string;
+    delegation?: string;
+    excludes?: string[];
+    name: string;
+    pk: string;
+    sig: string;
+    signer: string;
+    type: string;
+}
+export interface TStats {
+    downloads?: number;
+    purchases?: number;
+    star?: number;
+}
+export interface TTheme {
+    background?: string | {
+        default?: string;
+        footer?: string;
+        header?: string;
+    };
+}
+export declare type TTitle = string;

package/lib/types/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/indent */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/util-meta.d.ts

@@ -0,0 +1,42 @@
+import { TBlockletMeta, TComponent } from './types';
+declare const validateUrl: (url: string, expectedHttpResTypes?: string[]) => Promise<boolean>;
+declare const getBlockletMetaByUrl: (url: string) => Promise<TBlockletMeta>;
+declare const getBlockletMetaFromUrl: (url: string, { validateFn, returnUrl, ensureTarball, logger, }?: {
+    validateFn?: Function;
+    returnUrl?: boolean;
+    ensureTarball?: boolean;
+    logger?: any;
+}) => Promise<any>;
+declare const getBlockletMetaFromUrls: (urls: string[], { validateFn, returnUrl, ensureTarball, logger, }?: {
+    validateFn?: Function;
+    returnUrl?: boolean;
+    ensureTarball?: boolean;
+    logger?: any;
+}) => Promise<any>;
+/**
+ * @param {*} config defined in componentSchema in blocklet meta schema
+ */
+declare const getSourceUrlsFromConfig: (config: TComponent & any) => string[];
+export { validateUrl };
+export { getBlockletMetaByUrl };
+export { getBlockletMetaFromUrl };
+export { getBlockletMetaFromUrls };
+export { getSourceUrlsFromConfig };
+declare const _default: {
+    validateUrl: (url: string, expectedHttpResTypes?: string[]) => Promise<boolean>;
+    getBlockletMetaByUrl: (url: string) => Promise<TBlockletMeta>;
+    getBlockletMetaFromUrl: (url: string, { validateFn, returnUrl, ensureTarball, logger, }?: {
+        validateFn?: Function;
+        returnUrl?: boolean;
+        ensureTarball?: boolean;
+        logger?: any;
+    }) => Promise<any>;
+    getBlockletMetaFromUrls: (urls: string[], { validateFn, returnUrl, ensureTarball, logger, }?: {
+        validateFn?: Function;
+        returnUrl?: boolean;
+        ensureTarball?: boolean;
+        logger?: any;
+    }) => Promise<any>;
+    getSourceUrlsFromConfig: (config: any) => string[];
+};
+export default _default;