amis-core 1.0.0-beta.0

package/dist/utils/DataSchema.js

@@ -0,0 +1,120 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DataScope = require('./DataScope.js');
+var helper = require('./helper.js');
+
+/**
+ * 用来定义数据本身的数据结构，比如有类型是什么，有哪些属性。
+ */
+var DataSchema = /** @class */ (function () {
+    function DataSchema(schema) {
+        this.idMap = {};
+        this.root = new DataScope.DataScope(schema, 'root');
+        this.idMap['root'] = this.root;
+        this.current = this.root;
+    }
+    DataSchema.prototype.setSchema = function (schemas) {
+        this.current.setSchemas(schemas);
+        return this;
+    };
+    DataSchema.prototype.addSchema = function (schema) {
+        this.current.addSchema(schema);
+        return this;
+    };
+    DataSchema.prototype.removeSchema = function (id) {
+        this.current.removeSchema(id);
+        delete this.idMap[id];
+        return this;
+    };
+    DataSchema.prototype.getSchemas = function () {
+        var schemas = [];
+        var current = this.current;
+        while (current) {
+            schemas.push.apply(schemas, current.schemas);
+            current = current.parent;
+        }
+        return schemas;
+    };
+    DataSchema.prototype.addScope = function (schema, id) {
+        if (id === void 0) { id = helper.guid(); }
+        if (this.idMap[id]) {
+            throw new Error('scope id `' + id + '` already exists');
+        }
+        this.current = this.current.addChild(id, schema);
+        this.idMap[id] = this.current;
+        return this;
+    };
+    DataSchema.prototype.removeScope = function (idOrScope) {
+        var _a;
+        var scope = this.getScope(idOrScope);
+        if (!scope.parent) {
+            throw new Error('cannot remove root scope');
+        }
+        if (scope.contains(this.current)) {
+            this.current = scope.parent;
+        }
+        (_a = scope.parent) === null || _a === void 0 ? void 0 : _a.removeChild(scope);
+        delete this.idMap[scope.id];
+        return this;
+    };
+    DataSchema.prototype.hasScope = function (idOrScope) {
+        var id = typeof idOrScope === 'string' ? idOrScope : idOrScope.id;
+        var scope = this.idMap[id];
+        return !!scope;
+    };
+    DataSchema.prototype.getScope = function (idOrScope) {
+        var id = typeof idOrScope === 'string' ? idOrScope : idOrScope.id;
+        var scope = this.idMap[id];
+        if (!scope) {
+            throw new Error('scope not found!');
+        }
+        return scope;
+    };
+    DataSchema.prototype.switchToRoot = function () {
+        this.current = this.root;
+        return this;
+    };
+    DataSchema.prototype.switchTo = function (idOrScope) {
+        var scope = this.getScope(idOrScope);
+        this.current = scope;
+        return this;
+    };
+    DataSchema.prototype.getDataPropsAsOptions = function () {
+        var variables = [];
+        var current = this.current;
+        while (current) {
+            if (current.tag) {
+                variables.push({
+                    label: current.tag,
+                    children: current.getDataPropsAsOptions()
+                });
+            }
+            else {
+                variables.push.apply(variables, current.getDataPropsAsOptions());
+            }
+            current = current.parent;
+        }
+        return variables;
+    };
+    DataSchema.prototype.getSchemaByPath = function (path) {
+        var current = this.current;
+        while (current) {
+            var schema = current.getSchemaByPath(path);
+            if (schema) {
+                return schema;
+            }
+            current = current.parent;
+        }
+        return null;
+    };
+    return DataSchema;
+}());
+
+exports.DataSchema = DataSchema;

package/dist/utils/DataScope.js

@@ -0,0 +1,151 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var helper = require('./helper.js');
+var keyToPath = require('./keyToPath.js');
+
+var DataScope = /** @class */ (function () {
+    function DataScope(schemas, id) {
+        this.children = [];
+        this.schemas = [];
+        this.setSchemas(Array.isArray(schemas) ? schemas : [schemas]);
+        this.id = id;
+    }
+    DataScope.prototype.addChild = function (id, schema) {
+        var child = new DataScope(schema || {
+            type: 'object',
+            properties: {}
+        }, id);
+        this.children.push(child);
+        child.parent = this;
+        return child;
+    };
+    DataScope.prototype.removeChild = function (idOrScope) {
+        var idx = this.children.findIndex(function (item) {
+            return typeof idOrScope === 'string' ? idOrScope === item.id : item === idOrScope;
+        });
+        if (~idx) {
+            var scope = this.children[idx];
+            delete scope.parent;
+            this.children.splice(idx, 1);
+        }
+    };
+    DataScope.prototype.setSchemas = function (schemas) {
+        this.schemas.splice(0, this.schemas.length);
+        for (var _i = 0, schemas_1 = schemas; _i < schemas_1.length; _i++) {
+            var schema = schemas_1[_i];
+            if (schema.type !== 'object') {
+                throw new TypeError('data scope accept only object');
+            }
+            this.schemas.push(tslib.__assign({ $id: helper.guid() }, schema));
+        }
+        return this;
+    };
+    DataScope.prototype.addSchema = function (schema) {
+        schema = tslib.__assign({ $id: helper.guid() }, schema);
+        this.schemas.push(schema);
+        return this;
+    };
+    DataScope.prototype.removeSchema = function (id) {
+        var idx = this.schemas.findIndex(function (schema) { return schema.$id === id; });
+        if (~idx) {
+            this.schemas.splice(idx, 1);
+        }
+        return this;
+    };
+    DataScope.prototype.contains = function (scope) {
+        var from = scope;
+        while (from) {
+            if (this === from) {
+                return true;
+            }
+            from = from.parent;
+        }
+        return false;
+    };
+    DataScope.prototype.getMergedSchema = function () {
+        var mergedSchema = {
+            type: 'object',
+            properties: {}
+        };
+        // todo 以后再来细化这一块，先粗略的写个大概
+        this.schemas.forEach(function (schema) {
+            var properties = schema.properties || {};
+            Object.keys(properties).forEach(function (key) {
+                var value = properties[key];
+                if (mergedSchema.properties[key]) {
+                    if (Array.isArray(mergedSchema.properties[key].oneOf)) {
+                        mergedSchema.properties[key].oneOf.push();
+                    }
+                    else if (mergedSchema.properties[key].type &&
+                        mergedSchema.properties[key].type !== value.type) {
+                        mergedSchema.properties[key] = {
+                            oneOf: [mergedSchema.properties[key], value]
+                        };
+                    }
+                }
+                else {
+                    mergedSchema.properties[key] = value;
+                }
+            });
+        });
+        return mergedSchema;
+    };
+    DataScope.prototype.buildOptions = function (options, schema, path, key) {
+        var _this = this;
+        if (path === void 0) { path = ''; }
+        if (key === void 0) { key = ''; }
+        // todo 支持 oneOf, anyOf
+        var option = {
+            label: schema.title || key,
+            value: path,
+            type: schema.type,
+            description: schema.description
+        };
+        options.push(option);
+        if (schema.type === 'object' && schema.properties) {
+            option.children = [];
+            var keys = Object.keys(schema.properties);
+            keys.forEach(function (key) {
+                var child = schema.properties[key];
+                _this.buildOptions(option.children, child, path + (path ? '.' : '') + key, key);
+            });
+        }
+        else if (schema.type === 'array' && schema.items) {
+            option.children = [];
+            this.buildOptions(option.children, tslib.__assign({ title: 'Member' }, schema.items), path + (path ? '.' : '') + 'items', 'items');
+            option.children = helper.mapTree(option.children, function (item) { return (tslib.__assign(tslib.__assign({}, item), { disabled: true })); });
+        }
+    };
+    DataScope.prototype.getDataPropsAsOptions = function () {
+        var variables = [];
+        this.buildOptions(variables, this.getMergedSchema());
+        return variables[0].children;
+    };
+    DataScope.prototype.getSchemaByPath = function (path) {
+        var parts = keyToPath.keyToPath(path);
+        for (var _i = 0, _a = this.schemas; _i < _a.length; _i++) {
+            var schema = _a[_i];
+            var result = parts.reduce(function (schema, key) {
+                if (schema && schema.type === 'object' && schema.properties) {
+                    return schema.properties[key];
+                }
+                return null;
+            }, schema);
+            if (result) {
+                return result;
+            }
+        }
+        return null;
+    };
+    return DataScope;
+}());
+
+exports.DataScope = DataScope;

package/dist/utils/SimpleMap.js

@@ -0,0 +1,46 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var find = require('lodash/find');
+var findIndex = require('lodash/findIndex');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
+var findIndex__default = /*#__PURE__*/_interopDefaultLegacy(findIndex);
+
+var SimpleMap = /** @class */ (function () {
+    function SimpleMap() {
+        this.list = [];
+    }
+    SimpleMap.prototype.has = function (key) {
+        var resolved = find__default["default"](this.list, function (item) { return item.key === key; });
+        return !!resolved;
+    };
+    SimpleMap.prototype.set = function (key, value) {
+        this.list.push({
+            key: key,
+            value: value
+        });
+    };
+    SimpleMap.prototype.get = function (key) {
+        var resolved = find__default["default"](this.list, function (item) { return item.key === key; });
+        return resolved ? resolved.value : null;
+    };
+    SimpleMap.prototype.delete = function (key) {
+        var idx = findIndex__default["default"](this.list, function (item) { return item.key === key; });
+        ~idx && this.list.splice(idx, 1);
+    };
+    SimpleMap.prototype.dispose = function () {
+        this.list.splice(0, this.list.length);
+    };
+    return SimpleMap;
+}());
+
+exports.SimpleMap = SimpleMap;