@blocklet/resolver 1.16.12

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018-2020 ArcBlock
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,3 @@
+# Blocklet Constants
+
+Constants used in blocklet

package/index.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBlocklet = exports.parseComponents = exports.getComponentConfig = exports.validateBlockletMeta = exports.ensureMeta = exports.filterDuplicateComponents = exports.isDidMatchName = void 0;
+/* eslint-disable prettier/prettier */
+/* eslint-disable no-await-in-loop */
+const semver_1 = __importDefault(require("semver"));
+const did_1 = require("@arcblock/did");
+const constant_1 = require("@blocklet/constant");
+const util_1 = require("@blocklet/meta/lib/util");
+const schema_1 = require("@blocklet/meta/lib/schema");
+const validate_1 = require("@blocklet/meta/lib/validate");
+const util_meta_1 = require("@blocklet/meta/lib/util-meta");
+const did_2 = __importDefault(require("@blocklet/meta/lib/did"));
+const isDidMatchName = (did, name) => {
+    if ((0, did_1.isValid)(did) && name === did) {
+        return true;
+    }
+    return (0, did_2.default)(name) === did;
+};
+exports.isDidMatchName = isDidMatchName;
+const filterDuplicateComponents = (components = [], currents = []) => {
+    const arr = [];
+    components.forEach((component) => {
+        if (currents.some((x) => x.meta.did === component.meta.did)) {
+            return;
+        }
+        const index = arr.findIndex((x) => x.meta.did === component.meta.did);
+        if (index > -1) {
+            const exist = arr[index];
+            // 选择最小版本:
+            // 如果 com1 和 com2 都依赖某个 component, com1 声明依赖版本 1.0.0, 实际获取版本 1.0.0; com2 声明依赖版本 latest(不限), 实际获取版本 2.0.0 -> 则应该取 1.0.0
+            if (semver_1.default.lt(component.meta.version, exist.meta.version)) {
+                arr.splice(index, 1, component);
+            }
+        }
+        else {
+            arr.push(component);
+        }
+    });
+    return arr;
+};
+exports.filterDuplicateComponents = filterDuplicateComponents;
+/**
+ * set bundleDid and bundleMeta in meta
+ * update name and did to server index
+ * in app structure 2.0, application's bundleDid, bundleName, meta, did will be same
+ */
+const ensureMeta = (meta, { name, did } = {}) => {
+    if (name && did && !(0, exports.isDidMatchName)(did, name)) {
+        throw new Error(`name does not match with did: ${name}, ${did}`);
+    }
+    const newMeta = {
+        ...meta,
+    };
+    if (!newMeta.did || !newMeta.name || !(0, exports.isDidMatchName)(newMeta.did, newMeta.name)) {
+        throw new Error(`name does not match with did in meta: ${newMeta.name}, ${newMeta.did}`);
+    }
+    if (!meta.bundleDid) {
+        newMeta.bundleDid = meta.did;
+        newMeta.bundleName = meta.name;
+    }
+    if (name) {
+        newMeta.name = name;
+        newMeta.did = did || (0, did_2.default)(name);
+    }
+    return newMeta;
+};
+exports.ensureMeta = ensureMeta;
+const validateBlockletMeta = (meta, opts = {}) => {
+    (0, validate_1.fixAndValidateService)(meta);
+    return (0, validate_1.validateMeta)(meta, { ensureName: true, skipValidateDidName: true, schemaOptions: { ...opts } });
+};
+exports.validateBlockletMeta = validateBlockletMeta;
+const getComponentConfig = (meta) => {
+    const components = meta.components || meta.children || [];
+    const staticComponents = (meta.staticComponents || []).map((x) => ({ ...x, static: true }));
+    return [...components, ...staticComponents];
+};
+exports.getComponentConfig = getComponentConfig;
+const parseComponents = async (component, context = {}, logger = console) => {
+    const { ancestors = [], dynamicComponents = [] } = context;
+    if (ancestors.length > 40) {
+        throw new Error('The depth of component should not exceed 40');
+    }
+    // @ts-ignore
+    const configs = (0, exports.getComponentConfig)(component.meta) || [];
+    if (!configs || !configs.length) {
+        return {
+            staticComponents: [],
+            dynamicComponents,
+        };
+    }
+    const staticComponents = [];
+    for (const config of configs) {
+        const isStatic = !!config.static;
+        if (isStatic) {
+            if (!config.name) {
+                throw new Error(`Name does not found in child ${config.name}`);
+            }
+            if (!config.mountPoint) {
+                throw new Error(`MountPoint does not found in child ${config.name}`);
+            }
+        }
+    }
+    await Promise.all(configs.map(async (config) => {
+        const isStatic = !!config.static;
+        const urls = (0, util_meta_1.getSourceUrlsFromConfig)(config);
+        let rawMeta;
+        try {
+            rawMeta = await (0, util_meta_1.getBlockletMetaFromUrls)(urls, { logger });
+        }
+        catch (error) {
+            throw new Error(`Failed get component meta. Component: ${urls.join(', ')}, reason: ${error.message}`);
+        }
+        if (rawMeta.group === constant_1.BlockletGroup.gateway) {
+            throw new Error(`Cannot add gateway component ${rawMeta.title || rawMeta.did}`);
+        }
+        (0, exports.validateBlockletMeta)(rawMeta, { ensureDist: true });
+        if (!(0, util_1.isComponentBlocklet)(rawMeta)) {
+            throw new Error(`The blocklet cannot be a component: ${rawMeta.title}. The reason may be that the developer set capabilities.component to false in blocklet.yml`);
+        }
+        const webInterface = (0, util_1.findWebInterface)(rawMeta);
+        if (!webInterface) {
+            throw new Error(`Web interface does not found in component ${rawMeta.title || rawMeta.name}`);
+        }
+        const meta = (0, exports.ensureMeta)(rawMeta, { name: isStatic ? config.name : null });
+        // check circular dependencies
+        if (ancestors.map((x) => x.meta?.bundleDid).indexOf(meta.bundleDid) > -1) {
+            throw new Error('Blocklet components have circular dependencies');
+        }
+        if (config.title) {
+            meta.title = config.title;
+            meta.title = await schema_1.titleSchema.validateAsync(config.title);
+        }
+        if (config.description) {
+            meta.description = await schema_1.descriptionSchema.validateAsync(config.description);
+        }
+        const mountPoint = isStatic ? config.mountPoint : config.mountPoint || `/${meta.did}`;
+        const child = {
+            mountPoint,
+            meta,
+            bundleSource: config.source,
+            dependencies: [],
+            children: [],
+        };
+        if (isStatic) {
+            staticComponents.push(child);
+        }
+        else {
+            // @ts-ignore
+            dynamicComponents.push(child);
+            component.dependencies = component.dependencies || [];
+            component.dependencies.push({
+                did: child.meta.bundleDid,
+                required: !!config.required,
+                version: config.source.version || 'latest',
+            });
+        }
+        // @ts-ignore
+        await (0, exports.parseComponents)(child, { ancestors: [...ancestors, { meta }], dynamicComponents });
+    }));
+    component.children = staticComponents;
+    return {
+        staticComponents,
+        dynamicComponents,
+    };
+};
+exports.parseComponents = parseComponents;
+const parseBlocklet = async (url) => {
+    const meta = await (0, util_meta_1.getBlockletMetaFromUrl)(url);
+    const newChildMeta = (0, exports.ensureMeta)(meta);
+    // children
+    const newChild = {
+        // @ts-ignore
+        meta: newChildMeta,
+        mountPoint: '/',
+        bundleSource: { url },
+    };
+    const { dynamicComponents } = await (0, exports.parseComponents)(newChild);
+    dynamicComponents.unshift(newChild);
+    return dynamicComponents;
+};
+exports.parseBlocklet = parseBlocklet;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@blocklet/resolver",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.16.12",
+  "description": "Blocklet meta resolver",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "lint": "eslint tests index.ts",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "NODE_ENV=test node tools/jest.js",
+    "coverage": "npm run test -- --coverage",
+    "clean": "rm -f index.d.ts index.js",
+    "build": "npm run clean && tsc"
+  },
+  "author": "polunzh <polunzh@gmail.com> (http://github.com/polunzh)",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@arcblock/did": "^1.18.84",
+    "@blocklet/constant": "1.16.12",
+    "@blocklet/meta": "1.16.12",
+    "semver": "^7.3.8"
+  },
+  "devDependencies": {
+    "@arcblock/eslint-config-ts": "^0.2.4",
+    "@abtnode/types": "1.16.12",
+    "@types/jest": "^29.2.0",
+    "@types/node": "^18.11.0",
+    "@typescript-eslint/eslint-plugin": "^5.40.1",
+    "@typescript-eslint/parser": "^5.40.1",
+    "eslint": "^8.25.0",
+    "jest": "^27.5.1",
+    "prettier": "^2.7.1",
+    "ts-jest": "^27.1.5",
+    "typescript": "^5.0.4"
+  }
+}