@kp-ui/lowcode 1.0.20 → 1.0.21

package/es/node_modules/.pnpm/moddle@6.2.3/node_modules/moddle/dist/index.esm.js

@@ -0,0 +1,368 @@
+import { forEach as f, bind as m, assign as d, isString as b, isObject as $, set as M, pick as k } from "../../../../min-dash@4.2.3/node_modules/min-dash/dist/index.esm.js";
+function N() {
+}
+N.prototype.get = function(e) {
+  return this.$model.properties.get(this, e);
+};
+N.prototype.set = function(e, t) {
+  this.$model.properties.set(this, e, t);
+};
+function P(e, t) {
+  this.model = e, this.properties = t;
+}
+P.prototype.createType = function(e) {
+  var t = this.model, r = this.properties, i = Object.create(N.prototype);
+  f(e.properties, function(o) {
+    !o.isMany && o.default !== void 0 && (i[o.name] = o.default);
+  }), r.defineModel(i, t), r.defineDescriptor(i, e);
+  var s = e.ns.name;
+  function n(o) {
+    r.define(this, "$type", { value: s, enumerable: !0 }), r.define(this, "$attrs", { value: {} }), r.define(this, "$parent", { writable: !0 }), f(o, m(function(a, c) {
+      this.set(c, a);
+    }, this));
+  }
+  return n.prototype = i, n.hasType = i.$instanceOf = this.model.hasType, r.defineModel(n, t), r.defineDescriptor(n, e), n;
+};
+var D = {
+  String: !0,
+  Boolean: !0,
+  Integer: !0,
+  Real: !0,
+  Element: !0
+}, T = {
+  String: function(e) {
+    return e;
+  },
+  Boolean: function(e) {
+    return e === "true";
+  },
+  Integer: function(e) {
+    return parseInt(e, 10);
+  },
+  Real: function(e) {
+    return parseFloat(e);
+  }
+};
+function S(e, t) {
+  var r = T[e];
+  return r ? r(t) : t;
+}
+function v(e) {
+  return !!D[e];
+}
+function C(e) {
+  return !!T[e];
+}
+function u(e, t) {
+  var r = e.split(/:/), i, s;
+  if (r.length === 1)
+    i = e, s = t;
+  else if (r.length === 2)
+    i = r[1], s = r[0];
+  else
+    throw new Error("expected <prefix:localName> or <localName>, got " + e);
+  return e = (s ? s + ":" : "") + i, {
+    name: e,
+    prefix: s,
+    localName: i
+  };
+}
+function p(e) {
+  this.ns = e, this.name = e.name, this.allTypes = [], this.allTypesByName = {}, this.properties = [], this.propertiesByName = {};
+}
+p.prototype.build = function() {
+  return k(this, [
+    "ns",
+    "name",
+    "allTypes",
+    "allTypesByName",
+    "properties",
+    "propertiesByName",
+    "bodyProperty",
+    "idProperty"
+  ]);
+};
+p.prototype.addProperty = function(e, t, r) {
+  typeof t == "boolean" && (r = t, t = void 0), this.addNamedProperty(e, r !== !1);
+  var i = this.properties;
+  t !== void 0 ? i.splice(t, 0, e) : i.push(e);
+};
+p.prototype.replaceProperty = function(e, t, r) {
+  var i = e.ns, s = this.properties, n = this.propertiesByName, o = e.name !== t.name;
+  if (e.isId) {
+    if (!t.isId)
+      throw new Error(
+        "property <" + t.ns.name + "> must be id property to refine <" + e.ns.name + ">"
+      );
+    this.setIdProperty(t, !1);
+  }
+  if (e.isBody) {
+    if (!t.isBody)
+      throw new Error(
+        "property <" + t.ns.name + "> must be body property to refine <" + e.ns.name + ">"
+      );
+    this.setBodyProperty(t, !1);
+  }
+  var a = s.indexOf(e);
+  if (a === -1)
+    throw new Error("property <" + i.name + "> not found in property list");
+  s.splice(a, 1), this.addProperty(t, r ? void 0 : a, o), n[i.name] = n[i.localName] = t;
+};
+p.prototype.redefineProperty = function(e, t, r) {
+  var i = e.ns.prefix, s = t.split("#"), n = u(s[0], i), o = u(s[1], n.prefix).name, a = this.propertiesByName[o];
+  if (a)
+    this.replaceProperty(a, e, r);
+  else
+    throw new Error("refined property <" + o + "> not found");
+  delete e.redefines;
+};
+p.prototype.addNamedProperty = function(e, t) {
+  var r = e.ns, i = this.propertiesByName;
+  t && (this.assertNotDefined(e, r.name), this.assertNotDefined(e, r.localName)), i[r.name] = i[r.localName] = e;
+};
+p.prototype.removeNamedProperty = function(e) {
+  var t = e.ns, r = this.propertiesByName;
+  delete r[t.name], delete r[t.localName];
+};
+p.prototype.setBodyProperty = function(e, t) {
+  if (t && this.bodyProperty)
+    throw new Error(
+      "body property defined multiple times (<" + this.bodyProperty.ns.name + ">, <" + e.ns.name + ">)"
+    );
+  this.bodyProperty = e;
+};
+p.prototype.setIdProperty = function(e, t) {
+  if (t && this.idProperty)
+    throw new Error(
+      "id property defined multiple times (<" + this.idProperty.ns.name + ">, <" + e.ns.name + ">)"
+    );
+  this.idProperty = e;
+};
+p.prototype.assertNotTrait = function(e) {
+  if ((e.extends || []).length)
+    throw new Error(
+      `cannot create <${e.name}> extending <${e.extends}>`
+    );
+};
+p.prototype.assertNotDefined = function(e, t) {
+  var r = e.name, i = this.propertiesByName[r];
+  if (i)
+    throw new Error(
+      "property <" + r + "> already defined; override of <" + i.definedBy.ns.name + "#" + i.ns.name + "> by <" + e.definedBy.ns.name + "#" + e.ns.name + "> not allowed without redefines"
+    );
+};
+p.prototype.hasProperty = function(e) {
+  return this.propertiesByName[e];
+};
+p.prototype.addTrait = function(e, t) {
+  t && this.assertNotTrait(e);
+  var r = this.allTypesByName, i = this.allTypes, s = e.name;
+  s in r || (f(e.properties, m(function(n) {
+    n = d({}, n, {
+      name: n.ns.localName,
+      inherited: t
+    }), Object.defineProperty(n, "definedBy", {
+      value: e
+    });
+    var o = n.replaces, a = n.redefines;
+    o || a ? this.redefineProperty(n, o || a, o) : (n.isBody && this.setBodyProperty(n), n.isId && this.setIdProperty(n), this.addProperty(n));
+  }, this)), i.push(e), r[s] = e);
+};
+function l(e, t) {
+  this.packageMap = {}, this.typeMap = {}, this.packages = [], this.properties = t, f(e, m(this.registerPackage, this));
+}
+l.prototype.getPackage = function(e) {
+  return this.packageMap[e];
+};
+l.prototype.getPackages = function() {
+  return this.packages;
+};
+l.prototype.registerPackage = function(e) {
+  e = d({}, e);
+  var t = this.packageMap;
+  w(t, e, "prefix"), w(t, e, "uri"), f(e.types, m(function(r) {
+    this.registerType(r, e);
+  }, this)), t[e.uri] = t[e.prefix] = e, this.packages.push(e);
+};
+l.prototype.registerType = function(e, t) {
+  e = d({}, e, {
+    superClass: (e.superClass || []).slice(),
+    extends: (e.extends || []).slice(),
+    properties: (e.properties || []).slice(),
+    meta: d(e.meta || {})
+  });
+  var r = u(e.name, t.prefix), i = r.name, s = {};
+  f(e.properties, m(function(n) {
+    var o = u(n.name, r.prefix), a = o.name;
+    v(n.type) || (n.type = u(n.type, o.prefix).name), d(n, {
+      ns: o,
+      name: a
+    }), s[a] = n;
+  }, this)), d(e, {
+    ns: r,
+    name: i,
+    propertiesByName: s
+  }), f(e.extends, m(function(n) {
+    var o = u(n, r.prefix), a = this.typeMap[o.name];
+    a.traits = a.traits || [], a.traits.push(i);
+  }, this)), this.definePackage(e, t), this.typeMap[i] = e;
+};
+l.prototype.mapTypes = function(e, t, r) {
+  var i = v(e.name) ? { name: e.name } : this.typeMap[e.name], s = this;
+  function n(c, x) {
+    var E = u(c, v(c) ? "" : e.prefix);
+    s.mapTypes(E, t, x);
+  }
+  function o(c) {
+    return n(c, !0);
+  }
+  function a(c) {
+    return n(c, !1);
+  }
+  if (!i)
+    throw new Error("unknown type <" + e.name + ">");
+  f(i.superClass, r ? o : a), t(i, !r), f(i.traits, o);
+};
+l.prototype.getEffectiveDescriptor = function(e) {
+  var t = u(e), r = new p(t);
+  this.mapTypes(t, function(s, n) {
+    r.addTrait(s, n);
+  });
+  var i = r.build();
+  return this.definePackage(i, i.allTypes[i.allTypes.length - 1].$pkg), i;
+};
+l.prototype.definePackage = function(e, t) {
+  this.properties.define(e, "$pkg", { value: t });
+};
+function w(e, t, r) {
+  var i = t[r];
+  if (i in e)
+    throw new Error("package with " + r + " <" + i + "> already defined");
+}
+function h(e) {
+  this.model = e;
+}
+h.prototype.set = function(e, t, r) {
+  if (!b(t) || !t.length)
+    throw new TypeError("property name must be a non-empty string");
+  var i = this.getProperty(e, t), s = i && i.name;
+  I(r) ? i ? delete e[s] : delete e.$attrs[g(t)] : i ? s in e ? e[s] = r : B(e, i, r) : e.$attrs[g(t)] = r;
+};
+h.prototype.get = function(e, t) {
+  var r = this.getProperty(e, t);
+  if (!r)
+    return e.$attrs[g(t)];
+  var i = r.name;
+  return !e[i] && r.isMany && B(e, r, []), e[i];
+};
+h.prototype.define = function(e, t, r) {
+  if (!r.writable) {
+    var i = r.value;
+    r = d({}, r, {
+      get: function() {
+        return i;
+      }
+    }), delete r.value;
+  }
+  Object.defineProperty(e, t, r);
+};
+h.prototype.defineDescriptor = function(e, t) {
+  this.define(e, "$descriptor", { value: t });
+};
+h.prototype.defineModel = function(e, t) {
+  this.define(e, "$model", { value: t });
+};
+h.prototype.getProperty = function(e, t) {
+  var r = this.model, i = r.getPropertyDescriptor(e, t);
+  if (i)
+    return i;
+  if (t.includes(":"))
+    return null;
+  const s = r.config.strict;
+  if (typeof s < "u") {
+    const n = new TypeError(`unknown property <${t}> on <${e.$type}>`);
+    if (s)
+      throw n;
+    typeof console < "u" && console.warn(n);
+  }
+  return null;
+};
+function I(e) {
+  return typeof e > "u";
+}
+function B(e, t, r) {
+  Object.defineProperty(e, t.name, {
+    enumerable: !t.isReference,
+    writable: !0,
+    value: r,
+    configurable: !0
+  });
+}
+function g(e) {
+  return e.replace(/^:/, "");
+}
+function y(e, t = {}) {
+  this.properties = new h(this), this.factory = new P(this, this.properties), this.registry = new l(e, this.properties), this.typeCache = {}, this.config = t;
+}
+y.prototype.create = function(e, t) {
+  var r = this.getType(e);
+  if (!r)
+    throw new Error("unknown type <" + e + ">");
+  return new r(t);
+};
+y.prototype.getType = function(e) {
+  var t = this.typeCache, r = b(e) ? e : e.ns.name, i = t[r];
+  return i || (e = this.registry.getEffectiveDescriptor(r), i = t[r] = this.factory.createType(e)), i;
+};
+y.prototype.createAny = function(e, t, r) {
+  var i = u(e), s = {
+    $type: e,
+    $instanceOf: function(o) {
+      return o === this.$type;
+    },
+    get: function(o) {
+      return this[o];
+    },
+    set: function(o, a) {
+      M(this, [o], a);
+    }
+  }, n = {
+    name: e,
+    isGeneric: !0,
+    ns: {
+      prefix: i.prefix,
+      localName: i.localName,
+      uri: t
+    }
+  };
+  return this.properties.defineDescriptor(s, n), this.properties.defineModel(s, this), this.properties.define(s, "get", { enumerable: !1, writable: !0 }), this.properties.define(s, "set", { enumerable: !1, writable: !0 }), this.properties.define(s, "$parent", { enumerable: !1, writable: !0 }), this.properties.define(s, "$instanceOf", { enumerable: !1, writable: !0 }), f(r, function(o, a) {
+    $(o) && o.value !== void 0 ? s[o.name] = o.value : s[a] = o;
+  }), s;
+};
+y.prototype.getPackage = function(e) {
+  return this.registry.getPackage(e);
+};
+y.prototype.getPackages = function() {
+  return this.registry.getPackages();
+};
+y.prototype.getElementDescriptor = function(e) {
+  return e.$descriptor;
+};
+y.prototype.hasType = function(e, t) {
+  t === void 0 && (t = e, e = this);
+  var r = e.$model.getElementDescriptor(e);
+  return t in r.allTypesByName;
+};
+y.prototype.getPropertyDescriptor = function(e, t) {
+  return this.getElementDescriptor(e).propertiesByName[t];
+};
+y.prototype.getTypeDescriptor = function(e) {
+  return this.registry.typeMap[e];
+};
+export {
+  y as Moddle,
+  S as coerceType,
+  v as isBuiltInType,
+  C as isSimpleType,
+  u as parseNameNS
+};

package/es/node_modules/.pnpm/object-refs@0.3.0/node_modules/object-refs/index.js

@@ -0,0 +1,12 @@
+import { getDefaultExportFromCjs as r } from "../../../../../_virtual/_commonjsHelpers.js";
+import { __module as o } from "../../../../../_virtual/index.js";
+import t from "./lib/refs.js";
+import "./lib/collection.js";
+import { __exports as e } from "../../../../../_virtual/collection.js";
+o.exports = t;
+o.exports.Collection = e;
+var s = o.exports;
+const x = /* @__PURE__ */ r(s);
+export {
+  x as default
+};

package/es/node_modules/.pnpm/object-refs@0.3.0/node_modules/object-refs/lib/collection.js

@@ -0,0 +1,34 @@
+import { __exports as u } from "../../../../../../_virtual/collection.js";
+function o(t, n, d, f) {
+  var s = d.inverse;
+  return Object.defineProperty(t, "remove", {
+    value: function(e) {
+      var r = this.indexOf(e);
+      return r !== -1 && (this.splice(r, 1), n.unset(e, s, f)), e;
+    }
+  }), Object.defineProperty(t, "contains", {
+    value: function(e) {
+      return this.indexOf(e) !== -1;
+    }
+  }), Object.defineProperty(t, "add", {
+    value: function(e, r) {
+      var i = this.indexOf(e);
+      if (typeof r > "u") {
+        if (i !== -1)
+          return;
+        r = this.length;
+      }
+      i !== -1 && this.splice(i, 1), this.splice(r, 0, e), i === -1 && n.set(e, s, f);
+    }
+  }), Object.defineProperty(t, "__refs_collection", {
+    value: !0
+  }), t;
+}
+function c(t) {
+  return t.__refs_collection === !0;
+}
+u.extend = o;
+u.isExtended = c;
+export {
+  u as default
+};

package/es/node_modules/.pnpm/object-refs@0.3.0/node_modules/object-refs/lib/refs.js

@@ -0,0 +1,63 @@
+import { getDefaultExportFromCjs as m } from "../../../../../../_virtual/_commonjsHelpers.js";
+import "./collection.js";
+import { __exports as h } from "../../../../../../_virtual/collection.js";
+var c = h;
+function d(e, n) {
+  return Object.prototype.hasOwnProperty.call(e, n.name || n);
+}
+function t(e, n, i) {
+  var f = c.extend(i[n.name] || [], e, n, i);
+  Object.defineProperty(i, n.name, {
+    enumerable: n.enumerable,
+    value: f
+  }), f.length && f.forEach(function(o) {
+    e.set(o, n.inverse, i);
+  });
+}
+function r(e, n, i) {
+  var f = n.inverse, o = i[n.name];
+  Object.defineProperty(i, n.name, {
+    configurable: n.configurable,
+    enumerable: n.enumerable,
+    get: function() {
+      return o;
+    },
+    set: function(l) {
+      if (l !== o) {
+        var u = o;
+        o = null, u && e.unset(u, f, i), o = l, e.set(o, f, i);
+      }
+    }
+  });
+}
+function s(e, n) {
+  if (!(this instanceof s))
+    return new s(e, n);
+  e.inverse = n, n.inverse = e, this.props = {}, this.props[e.name] = e, this.props[n.name] = n;
+}
+s.prototype.bind = function(e, n) {
+  if (typeof n == "string") {
+    if (!this.props[n])
+      throw new Error("no property <" + n + "> in ref");
+    n = this.props[n];
+  }
+  n.collection ? t(this, n, e) : r(this, n, e);
+};
+s.prototype.ensureRefsCollection = function(e, n) {
+  var i = e[n.name];
+  return c.isExtended(i) || t(this, n, e), i;
+};
+s.prototype.ensureBound = function(e, n) {
+  d(e, n) || this.bind(e, n);
+};
+s.prototype.unset = function(e, n, i) {
+  e && (this.ensureBound(e, n), n.collection ? this.ensureRefsCollection(e, n).remove(i) : e[n.name] = void 0);
+};
+s.prototype.set = function(e, n, i) {
+  e && (this.ensureBound(e, n), n.collection ? this.ensureRefsCollection(e, n).add(i) : e[n.name] = i);
+};
+var a = s;
+const C = /* @__PURE__ */ m(a);
+export {
+  C as default
+};