@fecp/designer 5.5.47 → 5.5.49

package/lib/node_modules/moddle/dist/index.esm.js

@@ -0,0 +1,523 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index_esm = require("../../min-dash/dist/index.esm.js");
+function Base() {
+}
+Base.prototype.get = function(name) {
+  return this.$model.properties.get(this, name);
+};
+Base.prototype.set = function(name, value) {
+  this.$model.properties.set(this, name, value);
+};
+function Factory(model, properties) {
+  this.model = model;
+  this.properties = properties;
+}
+Factory.prototype.createType = function(descriptor) {
+  var model = this.model;
+  var props = this.properties, prototype = Object.create(Base.prototype);
+  index_esm.forEach(descriptor.properties, function(p) {
+    if (!p.isMany && p.default !== void 0) {
+      prototype[p.name] = p.default;
+    }
+  });
+  props.defineModel(prototype, model);
+  props.defineDescriptor(prototype, descriptor);
+  var name = descriptor.ns.name;
+  function ModdleElement(attrs) {
+    props.define(this, "$type", { value: name, enumerable: true });
+    props.define(this, "$attrs", { value: {} });
+    props.define(this, "$parent", { writable: true });
+    index_esm.forEach(attrs, index_esm.bind(function(val, key) {
+      this.set(key, val);
+    }, this));
+  }
+  ModdleElement.prototype = prototype;
+  ModdleElement.hasType = prototype.$instanceOf = this.model.hasType;
+  props.defineModel(ModdleElement, model);
+  props.defineDescriptor(ModdleElement, descriptor);
+  return ModdleElement;
+};
+var BUILTINS = {
+  String: true,
+  Boolean: true,
+  Integer: true,
+  Real: true,
+  Element: true
+};
+var TYPE_CONVERTERS = {
+  String: function(s) {
+    return s;
+  },
+  Boolean: function(s) {
+    return s === "true";
+  },
+  Integer: function(s) {
+    return parseInt(s, 10);
+  },
+  Real: function(s) {
+    return parseFloat(s);
+  }
+};
+function coerceType(type, value) {
+  var converter = TYPE_CONVERTERS[type];
+  if (converter) {
+    return converter(value);
+  } else {
+    return value;
+  }
+}
+function isBuiltIn(type) {
+  return !!BUILTINS[type];
+}
+function isSimple(type) {
+  return !!TYPE_CONVERTERS[type];
+}
+function parseName(name, defaultPrefix) {
+  var parts = name.split(/:/), localName, prefix;
+  if (parts.length === 1) {
+    localName = name;
+    prefix = defaultPrefix;
+  } else if (parts.length === 2) {
+    localName = parts[1];
+    prefix = parts[0];
+  } else {
+    throw new Error("expected <prefix:localName> or <localName>, got " + name);
+  }
+  name = (prefix ? prefix + ":" : "") + localName;
+  return {
+    name,
+    prefix,
+    localName
+  };
+}
+function DescriptorBuilder(nameNs) {
+  this.ns = nameNs;
+  this.name = nameNs.name;
+  this.allTypes = [];
+  this.allTypesByName = {};
+  this.properties = [];
+  this.propertiesByName = {};
+}
+DescriptorBuilder.prototype.build = function() {
+  return index_esm.pick(this, [
+    "ns",
+    "name",
+    "allTypes",
+    "allTypesByName",
+    "properties",
+    "propertiesByName",
+    "bodyProperty",
+    "idProperty"
+  ]);
+};
+DescriptorBuilder.prototype.addProperty = function(p, idx, validate) {
+  if (typeof idx === "boolean") {
+    validate = idx;
+    idx = void 0;
+  }
+  this.addNamedProperty(p, validate !== false);
+  var properties = this.properties;
+  if (idx !== void 0) {
+    properties.splice(idx, 0, p);
+  } else {
+    properties.push(p);
+  }
+};
+DescriptorBuilder.prototype.replaceProperty = function(oldProperty, newProperty, replace) {
+  var oldNameNs = oldProperty.ns;
+  var props = this.properties, propertiesByName = this.propertiesByName, rename = oldProperty.name !== newProperty.name;
+  if (oldProperty.isId) {
+    if (!newProperty.isId) {
+      throw new Error(
+        "property <" + newProperty.ns.name + "> must be id property to refine <" + oldProperty.ns.name + ">"
+      );
+    }
+    this.setIdProperty(newProperty, false);
+  }
+  if (oldProperty.isBody) {
+    if (!newProperty.isBody) {
+      throw new Error(
+        "property <" + newProperty.ns.name + "> must be body property to refine <" + oldProperty.ns.name + ">"
+      );
+    }
+    this.setBodyProperty(newProperty, false);
+  }
+  var idx = props.indexOf(oldProperty);
+  if (idx === -1) {
+    throw new Error("property <" + oldNameNs.name + "> not found in property list");
+  }
+  props.splice(idx, 1);
+  this.addProperty(newProperty, replace ? void 0 : idx, rename);
+  propertiesByName[oldNameNs.name] = propertiesByName[oldNameNs.localName] = newProperty;
+};
+DescriptorBuilder.prototype.redefineProperty = function(p, targetPropertyName, replace) {
+  var nsPrefix = p.ns.prefix;
+  var parts = targetPropertyName.split("#");
+  var name = parseName(parts[0], nsPrefix);
+  var attrName = parseName(parts[1], name.prefix).name;
+  var redefinedProperty = this.propertiesByName[attrName];
+  if (!redefinedProperty) {
+    throw new Error("refined property <" + attrName + "> not found");
+  } else {
+    this.replaceProperty(redefinedProperty, p, replace);
+  }
+  delete p.redefines;
+};
+DescriptorBuilder.prototype.addNamedProperty = function(p, validate) {
+  var ns = p.ns, propsByName = this.propertiesByName;
+  if (validate) {
+    this.assertNotDefined(p, ns.name);
+    this.assertNotDefined(p, ns.localName);
+  }
+  propsByName[ns.name] = propsByName[ns.localName] = p;
+};
+DescriptorBuilder.prototype.removeNamedProperty = function(p) {
+  var ns = p.ns, propsByName = this.propertiesByName;
+  delete propsByName[ns.name];
+  delete propsByName[ns.localName];
+};
+DescriptorBuilder.prototype.setBodyProperty = function(p, validate) {
+  if (validate && this.bodyProperty) {
+    throw new Error(
+      "body property defined multiple times (<" + this.bodyProperty.ns.name + ">, <" + p.ns.name + ">)"
+    );
+  }
+  this.bodyProperty = p;
+};
+DescriptorBuilder.prototype.setIdProperty = function(p, validate) {
+  if (validate && this.idProperty) {
+    throw new Error(
+      "id property defined multiple times (<" + this.idProperty.ns.name + ">, <" + p.ns.name + ">)"
+    );
+  }
+  this.idProperty = p;
+};
+DescriptorBuilder.prototype.assertNotTrait = function(typeDescriptor) {
+  const _extends = typeDescriptor.extends || [];
+  if (_extends.length) {
+    throw new Error(
+      `cannot create <${typeDescriptor.name}> extending <${typeDescriptor.extends}>`
+    );
+  }
+};
+DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
+  var propertyName = p.name, definedProperty = this.propertiesByName[propertyName];
+  if (definedProperty) {
+    throw new Error(
+      "property <" + propertyName + "> already defined; override of <" + definedProperty.definedBy.ns.name + "#" + definedProperty.ns.name + "> by <" + p.definedBy.ns.name + "#" + p.ns.name + "> not allowed without redefines"
+    );
+  }
+};
+DescriptorBuilder.prototype.hasProperty = function(name) {
+  return this.propertiesByName[name];
+};
+DescriptorBuilder.prototype.addTrait = function(t, inherited) {
+  if (inherited) {
+    this.assertNotTrait(t);
+  }
+  var typesByName = this.allTypesByName, types = this.allTypes;
+  var typeName = t.name;
+  if (typeName in typesByName) {
+    return;
+  }
+  index_esm.forEach(t.properties, index_esm.bind(function(p) {
+    p = index_esm.assign({}, p, {
+      name: p.ns.localName,
+      inherited
+    });
+    Object.defineProperty(p, "definedBy", {
+      value: t
+    });
+    var replaces = p.replaces, redefines = p.redefines;
+    if (replaces || redefines) {
+      this.redefineProperty(p, replaces || redefines, replaces);
+    } else {
+      if (p.isBody) {
+        this.setBodyProperty(p);
+      }
+      if (p.isId) {
+        this.setIdProperty(p);
+      }
+      this.addProperty(p);
+    }
+  }, this));
+  types.push(t);
+  typesByName[typeName] = t;
+};
+function Registry(packages, properties) {
+  this.packageMap = {};
+  this.typeMap = {};
+  this.packages = [];
+  this.properties = properties;
+  index_esm.forEach(packages, index_esm.bind(this.registerPackage, this));
+}
+Registry.prototype.getPackage = function(uriOrPrefix) {
+  return this.packageMap[uriOrPrefix];
+};
+Registry.prototype.getPackages = function() {
+  return this.packages;
+};
+Registry.prototype.registerPackage = function(pkg) {
+  pkg = index_esm.assign({}, pkg);
+  var pkgMap = this.packageMap;
+  ensureAvailable(pkgMap, pkg, "prefix");
+  ensureAvailable(pkgMap, pkg, "uri");
+  index_esm.forEach(pkg.types, index_esm.bind(function(descriptor) {
+    this.registerType(descriptor, pkg);
+  }, this));
+  pkgMap[pkg.uri] = pkgMap[pkg.prefix] = pkg;
+  this.packages.push(pkg);
+};
+Registry.prototype.registerType = function(type, pkg) {
+  type = index_esm.assign({}, type, {
+    superClass: (type.superClass || []).slice(),
+    extends: (type.extends || []).slice(),
+    properties: (type.properties || []).slice(),
+    meta: index_esm.assign(type.meta || {})
+  });
+  var ns = parseName(type.name, pkg.prefix), name = ns.name, propertiesByName = {};
+  index_esm.forEach(type.properties, index_esm.bind(function(p) {
+    var propertyNs = parseName(p.name, ns.prefix), propertyName = propertyNs.name;
+    if (!isBuiltIn(p.type)) {
+      p.type = parseName(p.type, propertyNs.prefix).name;
+    }
+    index_esm.assign(p, {
+      ns: propertyNs,
+      name: propertyName
+    });
+    propertiesByName[propertyName] = p;
+  }, this));
+  index_esm.assign(type, {
+    ns,
+    name,
+    propertiesByName
+  });
+  index_esm.forEach(type.extends, index_esm.bind(function(extendsName) {
+    var extendsNameNs = parseName(extendsName, ns.prefix);
+    var extended = this.typeMap[extendsNameNs.name];
+    extended.traits = extended.traits || [];
+    extended.traits.push(name);
+  }, this));
+  this.definePackage(type, pkg);
+  this.typeMap[name] = type;
+};
+Registry.prototype.mapTypes = function(nsName, iterator, trait) {
+  var type = isBuiltIn(nsName.name) ? { name: nsName.name } : this.typeMap[nsName.name];
+  var self = this;
+  function traverse(cls, trait2) {
+    var parentNs = parseName(cls, isBuiltIn(cls) ? "" : nsName.prefix);
+    self.mapTypes(parentNs, iterator, trait2);
+  }
+  function traverseTrait(cls) {
+    return traverse(cls, true);
+  }
+  function traverseSuper(cls) {
+    return traverse(cls, false);
+  }
+  if (!type) {
+    throw new Error("unknown type <" + nsName.name + ">");
+  }
+  index_esm.forEach(type.superClass, trait ? traverseTrait : traverseSuper);
+  iterator(type, !trait);
+  index_esm.forEach(type.traits, traverseTrait);
+};
+Registry.prototype.getEffectiveDescriptor = function(name) {
+  var nsName = parseName(name);
+  var builder = new DescriptorBuilder(nsName);
+  this.mapTypes(nsName, function(type, inherited) {
+    builder.addTrait(type, inherited);
+  });
+  var descriptor = builder.build();
+  this.definePackage(descriptor, descriptor.allTypes[descriptor.allTypes.length - 1].$pkg);
+  return descriptor;
+};
+Registry.prototype.definePackage = function(target, pkg) {
+  this.properties.define(target, "$pkg", { value: pkg });
+};
+function ensureAvailable(packageMap, pkg, identifierKey) {
+  var value = pkg[identifierKey];
+  if (value in packageMap) {
+    throw new Error("package with " + identifierKey + " <" + value + "> already defined");
+  }
+}
+function Properties(model) {
+  this.model = model;
+}
+Properties.prototype.set = function(target, name, value) {
+  if (!index_esm.isString(name) || !name.length) {
+    throw new TypeError("property name must be a non-empty string");
+  }
+  var property = this.getProperty(target, name);
+  var propertyName = property && property.name;
+  if (isUndefined(value)) {
+    if (property) {
+      delete target[propertyName];
+    } else {
+      delete target.$attrs[stripGlobal(name)];
+    }
+  } else {
+    if (property) {
+      if (propertyName in target) {
+        target[propertyName] = value;
+      } else {
+        defineProperty(target, property, value);
+      }
+    } else {
+      target.$attrs[stripGlobal(name)] = value;
+    }
+  }
+};
+Properties.prototype.get = function(target, name) {
+  var property = this.getProperty(target, name);
+  if (!property) {
+    return target.$attrs[stripGlobal(name)];
+  }
+  var propertyName = property.name;
+  if (!target[propertyName] && property.isMany) {
+    defineProperty(target, property, []);
+  }
+  return target[propertyName];
+};
+Properties.prototype.define = function(target, name, options) {
+  if (!options.writable) {
+    var value = options.value;
+    options = index_esm.assign({}, options, {
+      get: function() {
+        return value;
+      }
+    });
+    delete options.value;
+  }
+  Object.defineProperty(target, name, options);
+};
+Properties.prototype.defineDescriptor = function(target, descriptor) {
+  this.define(target, "$descriptor", { value: descriptor });
+};
+Properties.prototype.defineModel = function(target, model) {
+  this.define(target, "$model", { value: model });
+};
+Properties.prototype.getProperty = function(target, name) {
+  var model = this.model;
+  var property = model.getPropertyDescriptor(target, name);
+  if (property) {
+    return property;
+  }
+  if (name.includes(":")) {
+    return null;
+  }
+  const strict = model.config.strict;
+  if (typeof strict !== "undefined") {
+    const error = new TypeError(`unknown property <${name}> on <${target.$type}>`);
+    if (strict) {
+      throw error;
+    } else {
+      typeof console !== "undefined" && console.warn(error);
+    }
+  }
+  return null;
+};
+function isUndefined(val) {
+  return typeof val === "undefined";
+}
+function defineProperty(target, property, value) {
+  Object.defineProperty(target, property.name, {
+    enumerable: !property.isReference,
+    writable: true,
+    value,
+    configurable: true
+  });
+}
+function stripGlobal(name) {
+  return name.replace(/^:/, "");
+}
+function Moddle(packages, config = {}) {
+  this.properties = new Properties(this);
+  this.factory = new Factory(this, this.properties);
+  this.registry = new Registry(packages, this.properties);
+  this.typeCache = {};
+  this.config = config;
+}
+Moddle.prototype.create = function(descriptor, attrs) {
+  var Type = this.getType(descriptor);
+  if (!Type) {
+    throw new Error("unknown type <" + descriptor + ">");
+  }
+  return new Type(attrs);
+};
+Moddle.prototype.getType = function(descriptor) {
+  var cache = this.typeCache;
+  var name = index_esm.isString(descriptor) ? descriptor : descriptor.ns.name;
+  var type = cache[name];
+  if (!type) {
+    descriptor = this.registry.getEffectiveDescriptor(name);
+    type = cache[name] = this.factory.createType(descriptor);
+  }
+  return type;
+};
+Moddle.prototype.createAny = function(name, nsUri, properties) {
+  var nameNs = parseName(name);
+  var element = {
+    $type: name,
+    $instanceOf: function(type) {
+      return type === this.$type;
+    },
+    get: function(key) {
+      return this[key];
+    },
+    set: function(key, value) {
+      index_esm.set(this, [key], value);
+    }
+  };
+  var descriptor = {
+    name,
+    isGeneric: true,
+    ns: {
+      prefix: nameNs.prefix,
+      localName: nameNs.localName,
+      uri: nsUri
+    }
+  };
+  this.properties.defineDescriptor(element, descriptor);
+  this.properties.defineModel(element, this);
+  this.properties.define(element, "get", { enumerable: false, writable: true });
+  this.properties.define(element, "set", { enumerable: false, writable: true });
+  this.properties.define(element, "$parent", { enumerable: false, writable: true });
+  this.properties.define(element, "$instanceOf", { enumerable: false, writable: true });
+  index_esm.forEach(properties, function(a, key) {
+    if (index_esm.isObject(a) && a.value !== void 0) {
+      element[a.name] = a.value;
+    } else {
+      element[key] = a;
+    }
+  });
+  return element;
+};
+Moddle.prototype.getPackage = function(uriOrPrefix) {
+  return this.registry.getPackage(uriOrPrefix);
+};
+Moddle.prototype.getPackages = function() {
+  return this.registry.getPackages();
+};
+Moddle.prototype.getElementDescriptor = function(element) {
+  return element.$descriptor;
+};
+Moddle.prototype.hasType = function(element, type) {
+  if (type === void 0) {
+    type = element;
+    element = this;
+  }
+  var descriptor = element.$model.getElementDescriptor(element);
+  return type in descriptor.allTypesByName;
+};
+Moddle.prototype.getPropertyDescriptor = function(element, property) {
+  return this.getElementDescriptor(element).propertiesByName[property];
+};
+Moddle.prototype.getTypeDescriptor = function(type) {
+  return this.registry.typeMap[type];
+};
+exports.Moddle = Moddle;
+exports.coerceType = coerceType;
+exports.isBuiltInType = isBuiltIn;
+exports.isSimpleType = isSimple;
+exports.parseNameNS = parseName;