@xiping/react-components 1.0.19 → 1.0.21

package/dist/es/node_modules/.pnpm/ngraph.graph@20.0.1/node_modules/ngraph.graph/index.js

@@ -0,0 +1,319 @@
+import { __require as $ } from "../../../ngraph.events@1.2.2/node_modules/ngraph.events/index.js";
+var x, R;
+function ee() {
+  if (R) return x;
+  R = 1, x = F;
+  var b = $();
+  function F(t) {
+    if (t = t || {}, "uniqueLinkId" in t && (console.warn(
+      "ngraph.graph: Starting from version 0.14 `uniqueLinkId` is deprecated.\nUse `multigraph` option instead\n",
+      `
+`,
+      `Note: there is also change in default behavior: From now on each graph
+is considered to be not a multigraph by default (each edge is unique).`
+    ), t.multigraph = t.uniqueLinkId), t.multigraph === void 0 && (t.multigraph = !1), typeof Map != "function")
+      throw new Error("ngraph.graph requires `Map` to be defined. Please polyfill it before using ngraph");
+    var u = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), g = {}, m = 0, P = t.multigraph ? j : Y, l = [], w = N, L = N, v = N, c = N, h = {
+      /**
+       * Sometimes duck typing could be slow. Giving clients a hint about data structure
+       * via explicit version number here:
+       */
+      version: 20,
+      /**
+       * Adds node to the graph. If node with given id already exists in the graph
+       * its data is extended with whatever comes in 'data' argument.
+       *
+       * @param nodeId the node's identifier. A string or number is preferred.
+       * @param [data] additional data for the node being added. If node already
+       *   exists its data object is augmented with the new one.
+       *
+       * @return {node} The newly added node or node with given id if it already exists.
+       */
+      addNode: E,
+      /**
+       * Adds a link to the graph. The function always create a new
+       * link between two nodes. If one of the nodes does not exists
+       * a new node is created.
+       *
+       * @param fromId link start node id;
+       * @param toId link end node id;
+       * @param [data] additional data to be set on the new link;
+       *
+       * @return {link} The newly created link
+       */
+      addLink: V,
+      /**
+       * Removes link from the graph. If link does not exist does nothing.
+       *
+       * @param link - object returned by addLink() or getLinks() methods.
+       *
+       * @returns true if link was removed; false otherwise.
+       */
+      removeLink: B,
+      /**
+       * Removes node with given id from the graph. If node does not exist in the graph
+       * does nothing.
+       *
+       * @param nodeId node's identifier passed to addNode() function.
+       *
+       * @returns true if node was removed; false otherwise.
+       */
+      removeNode: M,
+      /**
+       * Gets node with given identifier. If node does not exist undefined value is returned.
+       *
+       * @param nodeId requested node identifier;
+       *
+       * @return {node} in with requested identifier or undefined if no such node exists.
+       */
+      getNode: d,
+      /**
+       * Gets number of nodes in this graph.
+       *
+       * @return number of nodes in the graph.
+       */
+      getNodeCount: _,
+      /**
+       * Gets total number of links in the graph.
+       */
+      getLinkCount: q,
+      /**
+       * Gets total number of links in the graph.
+       */
+      getEdgeCount: q,
+      /**
+       * Synonym for `getLinkCount()`
+       */
+      getLinksCount: q,
+      /**
+       * Synonym for `getNodeCount()`
+       */
+      getNodesCount: _,
+      /**
+       * Gets all links (inbound and outbound) from the node with given id.
+       * If node with given id is not found null is returned.
+       *
+       * @param nodeId requested node identifier.
+       *
+       * @return Set of links from and to requested node if such node exists;
+       *   otherwise null is returned.
+       */
+      getLinks: A,
+      /**
+       * Invokes callback on each node of the graph.
+       *
+       * @param {Function(node)} callback Function to be invoked. The function
+       *   is passed one argument: visited node.
+       */
+      forEachNode: S,
+      /**
+       * Invokes callback on every linked (adjacent) node to the given one.
+       *
+       * @param nodeId Identifier of the requested node.
+       * @param {Function(node, link)} callback Function to be called on all linked nodes.
+       *   The function is passed two parameters: adjacent node and link object itself.
+       * @param oriented if true graph treated as oriented.
+       */
+      forEachLinkedNode: J,
+      /**
+       * Enumerates all links in the graph
+       *
+       * @param {Function(link)} callback Function to be called on all links in the graph.
+       *   The function is passed one parameter: graph's link object.
+       *
+       * Link object contains at least the following fields:
+       *  fromId - node id where link starts;
+       *  toId - node id where link ends,
+       *  data - additional data passed to graph.addLink() method.
+       */
+      forEachLink: H,
+      /**
+       * Suspend all notifications about graph changes until
+       * endUpdate is called.
+       */
+      beginUpdate: v,
+      /**
+       * Resumes all notifications about graph changes and fires
+       * graph 'changed' event in case there are any pending changes.
+       */
+      endUpdate: c,
+      /**
+       * Removes all nodes and links from the graph.
+       */
+      clear: D,
+      /**
+       * Detects whether there is a link between two nodes.
+       * Operation complexity is O(n) where n - number of links of a node.
+       * NOTE: this function is synonym for getLink()
+       *
+       * @returns link if there is one. null otherwise.
+       */
+      hasLink: k,
+      /**
+       * Detects whether there is a node with given id
+       * 
+       * Operation complexity is O(1)
+       * NOTE: this function is synonym for getNode()
+       *
+       * @returns node if there is one; Falsy value otherwise.
+       */
+      hasNode: d,
+      /**
+       * Gets an edge between two nodes.
+       * Operation complexity is O(n) where n - number of links of a node.
+       *
+       * @param {string} fromId link start identifier
+       * @param {string} toId link end identifier
+       *
+       * @returns link if there is one; undefined otherwise.
+       */
+      getLink: k
+    };
+    return b(h), T(), h;
+    function T() {
+      var e = h.on;
+      h.on = n;
+      function n() {
+        return h.beginUpdate = v = W, h.endUpdate = c = X, w = z, L = G, h.on = e, e.apply(h, arguments);
+      }
+    }
+    function z(e, n) {
+      l.push({
+        link: e,
+        changeType: n
+      });
+    }
+    function G(e, n) {
+      l.push({
+        node: e,
+        changeType: n
+      });
+    }
+    function E(e, n) {
+      if (e === void 0)
+        throw new Error("Invalid node identifier");
+      v();
+      var r = d(e);
+      return r ? (r.data = n, L(r, "update")) : (r = new O(e, n), L(r, "add")), u.set(e, r), c(), r;
+    }
+    function d(e) {
+      return u.get(e);
+    }
+    function M(e) {
+      var n = d(e);
+      if (!n)
+        return !1;
+      v();
+      var r = n.links;
+      return r && (r.forEach(U), n.links = null), u.delete(e), L(n, "remove"), c(), !0;
+    }
+    function V(e, n, r) {
+      v();
+      var i = d(e) || E(e), o = d(n) || E(n), a = P(e, n, r), s = f.has(a.id);
+      return f.set(a.id, a), y(i, a), e !== n && y(o, a), w(a, s ? "update" : "add"), c(), a;
+    }
+    function Y(e, n, r) {
+      var i = p(e, n), o = f.get(i);
+      return o ? (o.data = r, o) : new C(e, n, r, i);
+    }
+    function j(e, n, r) {
+      var i = p(e, n), o = g.hasOwnProperty(i);
+      if (o || k(e, n)) {
+        o || (g[i] = 0);
+        var a = "@" + ++g[i];
+        i = p(e + a, n + a);
+      }
+      return new C(e, n, r, i);
+    }
+    function _() {
+      return u.size;
+    }
+    function q() {
+      return f.size;
+    }
+    function A(e) {
+      var n = d(e);
+      return n ? n.links : null;
+    }
+    function B(e, n) {
+      return n !== void 0 && (e = k(e, n)), U(e);
+    }
+    function U(e) {
+      if (!e || !f.get(e.id)) return !1;
+      v(), f.delete(e.id);
+      var n = d(e.fromId), r = d(e.toId);
+      return n && n.links.delete(e), r && r.links.delete(e), w(e, "remove"), c(), !0;
+    }
+    function k(e, n) {
+      if (!(e === void 0 || n === void 0))
+        return f.get(p(e, n));
+    }
+    function D() {
+      v(), S(function(e) {
+        M(e.id);
+      }), c();
+    }
+    function H(e) {
+      if (typeof e == "function")
+        for (var n = f.values(), r = n.next(); !r.done; ) {
+          if (e(r.value))
+            return !0;
+          r = n.next();
+        }
+    }
+    function J(e, n, r) {
+      var i = d(e);
+      if (i && i.links && typeof n == "function")
+        return r ? Q(i.links, e, n) : K(i.links, e, n);
+    }
+    function K(e, n, r) {
+      for (var i, o = e.values(), a = o.next(); !a.done; ) {
+        var s = a.value, Z = s.fromId === n ? s.toId : s.fromId;
+        if (i = r(u.get(Z), s), i)
+          return !0;
+        a = o.next();
+      }
+    }
+    function Q(e, n, r) {
+      for (var i, o = e.values(), a = o.next(); !a.done; ) {
+        var s = a.value;
+        if (s.fromId === n && (i = r(u.get(s.toId), s), i))
+          return !0;
+        a = o.next();
+      }
+    }
+    function N() {
+    }
+    function W() {
+      m += 1;
+    }
+    function X() {
+      m -= 1, m === 0 && l.length > 0 && (h.fire("changed", l), l.length = 0);
+    }
+    function S(e) {
+      if (typeof e != "function")
+        throw new Error("Function is expected to iterate over graph nodes. You passed " + e);
+      for (var n = u.values(), r = n.next(); !r.done; ) {
+        if (e(r.value))
+          return !0;
+        r = n.next();
+      }
+    }
+  }
+  function O(t, u) {
+    this.id = t, this.links = null, this.data = u;
+  }
+  function y(t, u) {
+    t.links ? t.links.add(u) : t.links = /* @__PURE__ */ new Set([u]);
+  }
+  function C(t, u, f, g) {
+    this.fromId = t, this.toId = u, this.data = f, this.id = g;
+  }
+  function p(t, u) {
+    return t.toString() + "👉 " + u.toString();
+  }
+  return x;
+}
+export {
+  ee as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.merge@1.0.0/node_modules/ngraph.merge/index.js

@@ -0,0 +1,20 @@
+var u, n;
+function v() {
+  if (n) return u;
+  n = 1, u = h;
+  function h(e, f) {
+    var r;
+    if (e || (e = {}), f) {
+      for (r in f)
+        if (f.hasOwnProperty(r)) {
+          var _ = e.hasOwnProperty(r), i = typeof f[r], m = !_ || typeof e[r] !== i;
+          m ? e[r] = f[r] : i === "object" && (e[r] = h(e[r], f[r]));
+        }
+    }
+    return e;
+  }
+  return u;
+}
+export {
+  v as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.random@1.2.0/node_modules/ngraph.random/index.js

@@ -0,0 +1,71 @@
+import { __module as i } from "../../../../../_virtual/index7.js";
+var p;
+function b() {
+  if (p) return i.exports;
+  p = 1, i.exports = u, i.exports.random = u, i.exports.randomIterator = l;
+  function u(t) {
+    var f = typeof t == "number" ? t : +/* @__PURE__ */ new Date();
+    return new o(f);
+  }
+  function o(t) {
+    this.seed = t;
+  }
+  o.prototype.next = m, o.prototype.nextDouble = a, o.prototype.uniform = a, o.prototype.gaussian = d, o.prototype.random = a;
+  function d() {
+    var t, f, r;
+    do
+      f = this.nextDouble() * 2 - 1, r = this.nextDouble() * 2 - 1, t = f * f + r * r;
+    while (t >= 1 || t === 0);
+    return f * Math.sqrt(-2 * Math.log(t) / t);
+  }
+  o.prototype.levy = c;
+  function c() {
+    var t = 1.5, f = Math.pow(
+      x(1 + t) * Math.sin(Math.PI * t / 2) / (x((1 + t) / 2) * t * Math.pow(2, (t - 1) / 2)),
+      1 / t
+    );
+    return this.gaussian() * f / Math.pow(Math.abs(this.gaussian()), 1 / t);
+  }
+  function x(t) {
+    return Math.sqrt(2 * Math.PI / t) * Math.pow(1 / Math.E * (t + 1 / (12 * t - 1 / (10 * t))), t);
+  }
+  function a() {
+    var t = this.seed;
+    return t = t + 2127912214 + (t << 12) & 4294967295, t = (t ^ 3345072700 ^ t >>> 19) & 4294967295, t = t + 374761393 + (t << 5) & 4294967295, t = (t + 3550635116 ^ t << 9) & 4294967295, t = t + 4251993797 + (t << 3) & 4294967295, t = (t ^ 3042594569 ^ t >>> 16) & 4294967295, this.seed = t, (t & 268435455) / 268435456;
+  }
+  function m(t) {
+    return Math.floor(this.nextDouble() * t);
+  }
+  function l(t, f) {
+    var r = f || u();
+    if (typeof r.next != "function")
+      throw new Error("customRandom does not match expected API: next() function is missing");
+    return {
+      /**
+       * Visits every single element of a collection once, in a random order.
+       * Note: collection is modified in place.
+       */
+      forEach: M,
+      /**
+       * Shuffles array randomly, in place.
+       */
+      shuffle: g
+    };
+    function g() {
+      var n, e, s;
+      for (n = t.length - 1; n > 0; --n)
+        e = r.next(n + 1), s = t[e], t[e] = t[n], t[n] = s;
+      return t;
+    }
+    function M(n) {
+      var e, s, h;
+      for (e = t.length - 1; e > 0; --e)
+        s = r.next(e + 1), h = t[s], t[s] = t[e], t[e] = h, n(h);
+      t.length && n(t[0]);
+    }
+  }
+  return i.exports;
+}
+export {
+  b as __require
+};

package/dist/es/node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js

@@ -0,0 +1,54 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var f, i;
+function p() {
+  if (i) return f;
+  i = 1;
+  var u = Object.getOwnPropertySymbols, b = Object.prototype.hasOwnProperty, l = Object.prototype.propertyIsEnumerable;
+  function O(n) {
+    if (n == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(n);
+  }
+  function j() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var n = new String("abc");
+      if (n[5] = "de", Object.getOwnPropertyNames(n)[0] === "5")
+        return !1;
+      for (var s = {}, r = 0; r < 10; r++)
+        s["_" + String.fromCharCode(r)] = r;
+      var a = Object.getOwnPropertyNames(s).map(function(e) {
+        return s[e];
+      });
+      if (a.join("") !== "0123456789")
+        return !1;
+      var t = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(e) {
+        t[e] = e;
+      }), Object.keys(Object.assign({}, t)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return f = j() ? Object.assign : function(n, s) {
+    for (var r, a = O(n), t, e = 1; e < arguments.length; e++) {
+      r = Object(arguments[e]);
+      for (var c in r)
+        b.call(r, c) && (a[c] = r[c]);
+      if (u) {
+        t = u(r);
+        for (var o = 0; o < t.length; o++)
+          l.call(r, t[o]) && (a[t[o]] = r[t[o]]);
+      }
+    }
+    return a;
+  }, f;
+}
+export {
+  p as __require
+};