x-state-lib 0.1.0

package/README.md

@@ -0,0 +1 @@
+# x-state-lib

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './state';

package/dist/index.js

@@ -0,0 +1,668 @@
+import { elements as k } from "x-runtime-lib";
+function Wt() {
+  return {
+    apps: [],
+    appid: "",
+    type: "page",
+    subtype: "",
+    version: "",
+    args: [],
+    nodes: []
+  };
+}
+function qt() {
+  return {
+    router: null,
+    i18n: null
+  };
+}
+function Yt() {
+  return {
+    spaces: {},
+    funcs: {},
+    flows: {},
+    activeFunc: {
+      id: "",
+      name: "",
+      inputs: [],
+      outputs: []
+    },
+    activeFlow: {
+      id: "",
+      name: ""
+    }
+  };
+}
+function Xt() {
+  return {
+    spaces: {},
+    tables: {}
+  };
+}
+function Jt() {
+  return {
+    spaces: {}
+  };
+}
+var $t = typeof global == "object" && global && global.Object === Object && global, Zt = typeof self == "object" && self && self.Object === Object && self, l = $t || Zt || Function("return this")(), j = l.Symbol, mt = Object.prototype, Qt = mt.hasOwnProperty, kt = mt.toString, A = j ? j.toStringTag : void 0;
+function te(t) {
+  var e = Qt.call(t, A), r = t[A];
+  try {
+    t[A] = void 0;
+    var n = !0;
+  } catch {
+  }
+  var s = kt.call(t);
+  return n && (e ? t[A] = r : delete t[A]), s;
+}
+var ee = Object.prototype, re = ee.toString;
+function ne(t) {
+  return re.call(t);
+}
+var ae = "[object Null]", oe = "[object Undefined]", tt = j ? j.toStringTag : void 0;
+function x(t) {
+  return t == null ? t === void 0 ? oe : ae : tt && tt in Object(t) ? te(t) : ne(t);
+}
+function C(t) {
+  return t != null && typeof t == "object";
+}
+var R = Array.isArray;
+function I(t) {
+  var e = typeof t;
+  return t != null && (e == "object" || e == "function");
+}
+var ie = "[object AsyncFunction]", se = "[object Function]", ce = "[object GeneratorFunction]", ue = "[object Proxy]";
+function wt(t) {
+  if (!I(t))
+    return !1;
+  var e = x(t);
+  return e == se || e == ce || e == ie || e == ue;
+}
+var B = l["__core-js_shared__"], et = function() {
+  var t = /[^.]+$/.exec(B && B.keys && B.keys.IE_PROTO || "");
+  return t ? "Symbol(src)_1." + t : "";
+}();
+function fe(t) {
+  return !!et && et in t;
+}
+var pe = Function.prototype, le = pe.toString;
+function _(t) {
+  if (t != null) {
+    try {
+      return le.call(t);
+    } catch {
+    }
+    try {
+      return t + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var ge = /[\\^$.*+?()[\]{}|]/g, be = /^\[object .+?Constructor\]$/, de = Function.prototype, he = Object.prototype, ye = de.toString, _e = he.hasOwnProperty, ve = RegExp(
+  "^" + ye.call(_e).replace(ge, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function Te(t) {
+  if (!I(t) || fe(t))
+    return !1;
+  var e = wt(t) ? ve : be;
+  return e.test(_(t));
+}
+function je(t, e) {
+  return t == null ? void 0 : t[e];
+}
+function v(t, e) {
+  var r = je(t, e);
+  return Te(r) ? r : void 0;
+}
+var U = v(l, "WeakMap"), rt = Object.create, $e = /* @__PURE__ */ function() {
+  function t() {
+  }
+  return function(e) {
+    if (!I(e))
+      return {};
+    if (rt)
+      return rt(e);
+    t.prototype = e;
+    var r = new t();
+    return t.prototype = void 0, r;
+  };
+}();
+function me(t, e) {
+  var r = -1, n = t.length;
+  for (e || (e = Array(n)); ++r < n; )
+    e[r] = t[r];
+  return e;
+}
+var nt = function() {
+  try {
+    var t = v(Object, "defineProperty");
+    return t({}, "", {}), t;
+  } catch {
+  }
+}();
+function we(t, e) {
+  for (var r = -1, n = t == null ? 0 : t.length; ++r < n && e(t[r], r, t) !== !1; )
+    ;
+  return t;
+}
+var Ae = 9007199254740991, Oe = /^(?:0|[1-9]\d*)$/;
+function Se(t, e) {
+  var r = typeof t;
+  return e = e ?? Ae, !!e && (r == "number" || r != "symbol" && Oe.test(t)) && t > -1 && t % 1 == 0 && t < e;
+}
+function At(t, e, r) {
+  e == "__proto__" && nt ? nt(t, e, {
+    configurable: !0,
+    enumerable: !0,
+    value: r,
+    writable: !0
+  }) : t[e] = r;
+}
+function Ot(t, e) {
+  return t === e || t !== t && e !== e;
+}
+var Pe = Object.prototype, xe = Pe.hasOwnProperty;
+function St(t, e, r) {
+  var n = t[e];
+  (!(xe.call(t, e) && Ot(n, r)) || r === void 0 && !(e in t)) && At(t, e, r);
+}
+function F(t, e, r, n) {
+  var s = !r;
+  r || (r = {});
+  for (var c = -1, o = e.length; ++c < o; ) {
+    var u = e[c], f = void 0;
+    f === void 0 && (f = t[u]), s ? At(r, u, f) : St(r, u, f);
+  }
+  return r;
+}
+var Ce = 9007199254740991;
+function Pt(t) {
+  return typeof t == "number" && t > -1 && t % 1 == 0 && t <= Ce;
+}
+function xt(t) {
+  return t != null && Pt(t.length) && !wt(t);
+}
+var Ie = Object.prototype;
+function H(t) {
+  var e = t && t.constructor, r = typeof e == "function" && e.prototype || Ie;
+  return t === r;
+}
+function Ee(t, e) {
+  for (var r = -1, n = Array(t); ++r < t; )
+    n[r] = e(r);
+  return n;
+}
+var Fe = "[object Arguments]";
+function at(t) {
+  return C(t) && x(t) == Fe;
+}
+var Ct = Object.prototype, Me = Ct.hasOwnProperty, De = Ct.propertyIsEnumerable, Be = at(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? at : function(t) {
+  return C(t) && Me.call(t, "callee") && !De.call(t, "callee");
+};
+function Le() {
+  return !1;
+}
+var It = typeof exports == "object" && exports && !exports.nodeType && exports, ot = It && typeof module == "object" && module && !module.nodeType && module, Ue = ot && ot.exports === It, it = Ue ? l.Buffer : void 0, ze = it ? it.isBuffer : void 0, Et = ze || Le, Ge = "[object Arguments]", Ne = "[object Array]", Re = "[object Boolean]", He = "[object Date]", Ke = "[object Error]", Ve = "[object Function]", We = "[object Map]", qe = "[object Number]", Ye = "[object Object]", Xe = "[object RegExp]", Je = "[object Set]", Ze = "[object String]", Qe = "[object WeakMap]", ke = "[object ArrayBuffer]", tr = "[object DataView]", er = "[object Float32Array]", rr = "[object Float64Array]", nr = "[object Int8Array]", ar = "[object Int16Array]", or = "[object Int32Array]", ir = "[object Uint8Array]", sr = "[object Uint8ClampedArray]", cr = "[object Uint16Array]", ur = "[object Uint32Array]", i = {};
+i[er] = i[rr] = i[nr] = i[ar] = i[or] = i[ir] = i[sr] = i[cr] = i[ur] = !0;
+i[Ge] = i[Ne] = i[ke] = i[Re] = i[tr] = i[He] = i[Ke] = i[Ve] = i[We] = i[qe] = i[Ye] = i[Xe] = i[Je] = i[Ze] = i[Qe] = !1;
+function fr(t) {
+  return C(t) && Pt(t.length) && !!i[x(t)];
+}
+function K(t) {
+  return function(e) {
+    return t(e);
+  };
+}
+var Ft = typeof exports == "object" && exports && !exports.nodeType && exports, O = Ft && typeof module == "object" && module && !module.nodeType && module, pr = O && O.exports === Ft, L = pr && $t.process, $ = function() {
+  try {
+    var t = O && O.require && O.require("util").types;
+    return t || L && L.binding && L.binding("util");
+  } catch {
+  }
+}(), st = $ && $.isTypedArray, lr = st ? K(st) : fr, gr = Object.prototype, br = gr.hasOwnProperty;
+function Mt(t, e) {
+  var r = R(t), n = !r && Be(t), s = !r && !n && Et(t), c = !r && !n && !s && lr(t), o = r || n || s || c, u = o ? Ee(t.length, String) : [], f = u.length;
+  for (var p in t)
+    (e || br.call(t, p)) && !(o && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (p == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    s && (p == "offset" || p == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    c && (p == "buffer" || p == "byteLength" || p == "byteOffset") || // Skip index properties.
+    Se(p, f))) && u.push(p);
+  return u;
+}
+function Dt(t, e) {
+  return function(r) {
+    return t(e(r));
+  };
+}
+var dr = Dt(Object.keys, Object), hr = Object.prototype, yr = hr.hasOwnProperty;
+function _r(t) {
+  if (!H(t))
+    return dr(t);
+  var e = [];
+  for (var r in Object(t))
+    yr.call(t, r) && r != "constructor" && e.push(r);
+  return e;
+}
+function V(t) {
+  return xt(t) ? Mt(t) : _r(t);
+}
+function vr(t) {
+  var e = [];
+  if (t != null)
+    for (var r in Object(t))
+      e.push(r);
+  return e;
+}
+var Tr = Object.prototype, jr = Tr.hasOwnProperty;
+function $r(t) {
+  if (!I(t))
+    return vr(t);
+  var e = H(t), r = [];
+  for (var n in t)
+    n == "constructor" && (e || !jr.call(t, n)) || r.push(n);
+  return r;
+}
+function W(t) {
+  return xt(t) ? Mt(t, !0) : $r(t);
+}
+var S = v(Object, "create");
+function mr() {
+  this.__data__ = S ? S(null) : {}, this.size = 0;
+}
+function wr(t) {
+  var e = this.has(t) && delete this.__data__[t];
+  return this.size -= e ? 1 : 0, e;
+}
+var Ar = "__lodash_hash_undefined__", Or = Object.prototype, Sr = Or.hasOwnProperty;
+function Pr(t) {
+  var e = this.__data__;
+  if (S) {
+    var r = e[t];
+    return r === Ar ? void 0 : r;
+  }
+  return Sr.call(e, t) ? e[t] : void 0;
+}
+var xr = Object.prototype, Cr = xr.hasOwnProperty;
+function Ir(t) {
+  var e = this.__data__;
+  return S ? e[t] !== void 0 : Cr.call(e, t);
+}
+var Er = "__lodash_hash_undefined__";
+function Fr(t, e) {
+  var r = this.__data__;
+  return this.size += this.has(t) ? 0 : 1, r[t] = S && e === void 0 ? Er : e, this;
+}
+function y(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var n = t[e];
+    this.set(n[0], n[1]);
+  }
+}
+y.prototype.clear = mr;
+y.prototype.delete = wr;
+y.prototype.get = Pr;
+y.prototype.has = Ir;
+y.prototype.set = Fr;
+function Mr() {
+  this.__data__ = [], this.size = 0;
+}
+function M(t, e) {
+  for (var r = t.length; r--; )
+    if (Ot(t[r][0], e))
+      return r;
+  return -1;
+}
+var Dr = Array.prototype, Br = Dr.splice;
+function Lr(t) {
+  var e = this.__data__, r = M(e, t);
+  if (r < 0)
+    return !1;
+  var n = e.length - 1;
+  return r == n ? e.pop() : Br.call(e, r, 1), --this.size, !0;
+}
+function Ur(t) {
+  var e = this.__data__, r = M(e, t);
+  return r < 0 ? void 0 : e[r][1];
+}
+function zr(t) {
+  return M(this.__data__, t) > -1;
+}
+function Gr(t, e) {
+  var r = this.__data__, n = M(r, t);
+  return n < 0 ? (++this.size, r.push([t, e])) : r[n][1] = e, this;
+}
+function b(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var n = t[e];
+    this.set(n[0], n[1]);
+  }
+}
+b.prototype.clear = Mr;
+b.prototype.delete = Lr;
+b.prototype.get = Ur;
+b.prototype.has = zr;
+b.prototype.set = Gr;
+var P = v(l, "Map");
+function Nr() {
+  this.size = 0, this.__data__ = {
+    hash: new y(),
+    map: new (P || b)(),
+    string: new y()
+  };
+}
+function Rr(t) {
+  var e = typeof t;
+  return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? t !== "__proto__" : t === null;
+}
+function D(t, e) {
+  var r = t.__data__;
+  return Rr(e) ? r[typeof e == "string" ? "string" : "hash"] : r.map;
+}
+function Hr(t) {
+  var e = D(this, t).delete(t);
+  return this.size -= e ? 1 : 0, e;
+}
+function Kr(t) {
+  return D(this, t).get(t);
+}
+function Vr(t) {
+  return D(this, t).has(t);
+}
+function Wr(t, e) {
+  var r = D(this, t), n = r.size;
+  return r.set(t, e), this.size += r.size == n ? 0 : 1, this;
+}
+function m(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var n = t[e];
+    this.set(n[0], n[1]);
+  }
+}
+m.prototype.clear = Nr;
+m.prototype.delete = Hr;
+m.prototype.get = Kr;
+m.prototype.has = Vr;
+m.prototype.set = Wr;
+function Bt(t, e) {
+  for (var r = -1, n = e.length, s = t.length; ++r < n; )
+    t[s + r] = e[r];
+  return t;
+}
+var Lt = Dt(Object.getPrototypeOf, Object);
+function qr() {
+  this.__data__ = new b(), this.size = 0;
+}
+function Yr(t) {
+  var e = this.__data__, r = e.delete(t);
+  return this.size = e.size, r;
+}
+function Xr(t) {
+  return this.__data__.get(t);
+}
+function Jr(t) {
+  return this.__data__.has(t);
+}
+var Zr = 200;
+function Qr(t, e) {
+  var r = this.__data__;
+  if (r instanceof b) {
+    var n = r.__data__;
+    if (!P || n.length < Zr - 1)
+      return n.push([t, e]), this.size = ++r.size, this;
+    r = this.__data__ = new m(n);
+  }
+  return r.set(t, e), this.size = r.size, this;
+}
+function w(t) {
+  var e = this.__data__ = new b(t);
+  this.size = e.size;
+}
+w.prototype.clear = qr;
+w.prototype.delete = Yr;
+w.prototype.get = Xr;
+w.prototype.has = Jr;
+w.prototype.set = Qr;
+function kr(t, e) {
+  return t && F(e, V(e), t);
+}
+function tn(t, e) {
+  return t && F(e, W(e), t);
+}
+var Ut = typeof exports == "object" && exports && !exports.nodeType && exports, ct = Ut && typeof module == "object" && module && !module.nodeType && module, en = ct && ct.exports === Ut, ut = en ? l.Buffer : void 0, ft = ut ? ut.allocUnsafe : void 0;
+function rn(t, e) {
+  if (e)
+    return t.slice();
+  var r = t.length, n = ft ? ft(r) : new t.constructor(r);
+  return t.copy(n), n;
+}
+function nn(t, e) {
+  for (var r = -1, n = t == null ? 0 : t.length, s = 0, c = []; ++r < n; ) {
+    var o = t[r];
+    e(o, r, t) && (c[s++] = o);
+  }
+  return c;
+}
+function zt() {
+  return [];
+}
+var an = Object.prototype, on = an.propertyIsEnumerable, pt = Object.getOwnPropertySymbols, q = pt ? function(t) {
+  return t == null ? [] : (t = Object(t), nn(pt(t), function(e) {
+    return on.call(t, e);
+  }));
+} : zt;
+function sn(t, e) {
+  return F(t, q(t), e);
+}
+var cn = Object.getOwnPropertySymbols, Gt = cn ? function(t) {
+  for (var e = []; t; )
+    Bt(e, q(t)), t = Lt(t);
+  return e;
+} : zt;
+function un(t, e) {
+  return F(t, Gt(t), e);
+}
+function Nt(t, e, r) {
+  var n = e(t);
+  return R(t) ? n : Bt(n, r(t));
+}
+function fn(t) {
+  return Nt(t, V, q);
+}
+function pn(t) {
+  return Nt(t, W, Gt);
+}
+var z = v(l, "DataView"), G = v(l, "Promise"), N = v(l, "Set"), lt = "[object Map]", ln = "[object Object]", gt = "[object Promise]", bt = "[object Set]", dt = "[object WeakMap]", ht = "[object DataView]", gn = _(z), bn = _(P), dn = _(G), hn = _(N), yn = _(U), g = x;
+(z && g(new z(new ArrayBuffer(1))) != ht || P && g(new P()) != lt || G && g(G.resolve()) != gt || N && g(new N()) != bt || U && g(new U()) != dt) && (g = function(t) {
+  var e = x(t), r = e == ln ? t.constructor : void 0, n = r ? _(r) : "";
+  if (n)
+    switch (n) {
+      case gn:
+        return ht;
+      case bn:
+        return lt;
+      case dn:
+        return gt;
+      case hn:
+        return bt;
+      case yn:
+        return dt;
+    }
+  return e;
+});
+var _n = Object.prototype, vn = _n.hasOwnProperty;
+function Tn(t) {
+  var e = t.length, r = new t.constructor(e);
+  return e && typeof t[0] == "string" && vn.call(t, "index") && (r.index = t.index, r.input = t.input), r;
+}
+var yt = l.Uint8Array;
+function Y(t) {
+  var e = new t.constructor(t.byteLength);
+  return new yt(e).set(new yt(t)), e;
+}
+function jn(t, e) {
+  var r = e ? Y(t.buffer) : t.buffer;
+  return new t.constructor(r, t.byteOffset, t.byteLength);
+}
+var $n = /\w*$/;
+function mn(t) {
+  var e = new t.constructor(t.source, $n.exec(t));
+  return e.lastIndex = t.lastIndex, e;
+}
+var _t = j ? j.prototype : void 0, vt = _t ? _t.valueOf : void 0;
+function wn(t) {
+  return vt ? Object(vt.call(t)) : {};
+}
+function An(t, e) {
+  var r = e ? Y(t.buffer) : t.buffer;
+  return new t.constructor(r, t.byteOffset, t.length);
+}
+var On = "[object Boolean]", Sn = "[object Date]", Pn = "[object Map]", xn = "[object Number]", Cn = "[object RegExp]", In = "[object Set]", En = "[object String]", Fn = "[object Symbol]", Mn = "[object ArrayBuffer]", Dn = "[object DataView]", Bn = "[object Float32Array]", Ln = "[object Float64Array]", Un = "[object Int8Array]", zn = "[object Int16Array]", Gn = "[object Int32Array]", Nn = "[object Uint8Array]", Rn = "[object Uint8ClampedArray]", Hn = "[object Uint16Array]", Kn = "[object Uint32Array]";
+function Vn(t, e, r) {
+  var n = t.constructor;
+  switch (e) {
+    case Mn:
+      return Y(t);
+    case On:
+    case Sn:
+      return new n(+t);
+    case Dn:
+      return jn(t, r);
+    case Bn:
+    case Ln:
+    case Un:
+    case zn:
+    case Gn:
+    case Nn:
+    case Rn:
+    case Hn:
+    case Kn:
+      return An(t, r);
+    case Pn:
+      return new n();
+    case xn:
+    case En:
+      return new n(t);
+    case Cn:
+      return mn(t);
+    case In:
+      return new n();
+    case Fn:
+      return wn(t);
+  }
+}
+function Wn(t) {
+  return typeof t.constructor == "function" && !H(t) ? $e(Lt(t)) : {};
+}
+var qn = "[object Map]";
+function Yn(t) {
+  return C(t) && g(t) == qn;
+}
+var Tt = $ && $.isMap, Xn = Tt ? K(Tt) : Yn, Jn = "[object Set]";
+function Zn(t) {
+  return C(t) && g(t) == Jn;
+}
+var jt = $ && $.isSet, Qn = jt ? K(jt) : Zn, kn = 1, ta = 2, ea = 4, Rt = "[object Arguments]", ra = "[object Array]", na = "[object Boolean]", aa = "[object Date]", oa = "[object Error]", Ht = "[object Function]", ia = "[object GeneratorFunction]", sa = "[object Map]", ca = "[object Number]", Kt = "[object Object]", ua = "[object RegExp]", fa = "[object Set]", pa = "[object String]", la = "[object Symbol]", ga = "[object WeakMap]", ba = "[object ArrayBuffer]", da = "[object DataView]", ha = "[object Float32Array]", ya = "[object Float64Array]", _a = "[object Int8Array]", va = "[object Int16Array]", Ta = "[object Int32Array]", ja = "[object Uint8Array]", $a = "[object Uint8ClampedArray]", ma = "[object Uint16Array]", wa = "[object Uint32Array]", a = {};
+a[Rt] = a[ra] = a[ba] = a[da] = a[na] = a[aa] = a[ha] = a[ya] = a[_a] = a[va] = a[Ta] = a[sa] = a[ca] = a[Kt] = a[ua] = a[fa] = a[pa] = a[la] = a[ja] = a[$a] = a[ma] = a[wa] = !0;
+a[oa] = a[Ht] = a[ga] = !1;
+function E(t, e, r, n, s, c) {
+  var o, u = e & kn, f = e & ta, p = e & ea;
+  if (o !== void 0)
+    return o;
+  if (!I(t))
+    return t;
+  var X = R(t);
+  if (X) {
+    if (o = Tn(t), !u)
+      return me(t, o);
+  } else {
+    var T = g(t), J = T == Ht || T == ia;
+    if (Et(t))
+      return rn(t, u);
+    if (T == Kt || T == Rt || J && !s) {
+      if (o = f || J ? {} : Wn(t), !u)
+        return f ? un(t, tn(o, t)) : sn(t, kr(o, t));
+    } else {
+      if (!a[T])
+        return s ? t : {};
+      o = Vn(t, T, u);
+    }
+  }
+  c || (c = new w());
+  var Z = c.get(t);
+  if (Z)
+    return Z;
+  c.set(t, o), Qn(t) ? t.forEach(function(d) {
+    o.add(E(d, e, r, d, t, c));
+  }) : Xn(t) && t.forEach(function(d, h) {
+    o.set(h, E(d, e, r, h, t, c));
+  });
+  var Vt = p ? f ? pn : fn : f ? W : V, Q = X ? void 0 : Vt(t);
+  return we(Q || t, function(d, h) {
+    Q && (h = d, d = t[h]), St(o, h, E(d, e, r, h, t, c));
+  }), o;
+}
+var Aa = 1, Oa = 4;
+function Sa(t) {
+  return E(t, Aa | Oa);
+}
+function Pa() {
+  return {
+    props: {}
+  };
+}
+function Ia() {
+  const t = {};
+  for (const e in k) {
+    const r = {}, n = k[e];
+    for (const s in n.props)
+      r[s] = xa(n.props[s]);
+    t[e] = r;
+  }
+  return t;
+}
+function xa(t) {
+  const e = [], r = (n, s, c) => {
+    if (s !== "" && (s += "."), s += n.key, c = Sa(c), c.push(n.name), !n.ui && !n.array)
+      n.children.forEach((o) => r(o, s, c));
+    else {
+      if (n.ui === "strInput" && n.static)
+        return;
+      const o = {
+        keys: s,
+        names: c,
+        raw: n
+      };
+      e.push(o);
+    }
+  };
+  return t.forEach((n) => {
+    r(n, "", []);
+  }), e;
+}
+const Ea = function() {
+  return window.blocklyState || (window.blocklyState = {
+    base: qt(),
+    runtime: Pa(),
+    app: Wt(),
+    compute: Yt(),
+    data: Xt(),
+    resource: Jt()
+  }), window.blocklyState;
+}();
+export {
+  Ea as blocklyState,
+  Ia as buildProps,
+  Wt as initApp,
+  qt as initBase,
+  Yt as initCompute,
+  Xt as initData,
+  Jt as initResource,
+  Pa as initRuntime
+};

package/dist/state/app.d.ts

@@ -0,0 +1,28 @@
+export type App = {
+    id: string;
+    name: string;
+    pages: {
+        id: string;
+        name: string;
+    }[];
+};
+export type Arg = {
+    id: string;
+    name: string;
+    type: string;
+};
+export type Node = {
+    id: string;
+    key: string;
+    alias: string;
+};
+export type App2 = {
+    apps: App[];
+    appid: '';
+    type: 'page' | 'comp';
+    subtype: string;
+    version: string;
+    args: Arg[];
+    nodes: Node[];
+};
+export declare function initApp(): App2;

package/dist/state/base.d.ts

@@ -0,0 +1,5 @@
+export type Base = {
+    router: any;
+    i18n: any;
+};
+export declare function initBase(): Base;

package/dist/state/compute.d.ts

@@ -0,0 +1,63 @@
+export type ComputeSpace = {
+    id: string;
+    name: string;
+    sort: number;
+};
+export type Func = {
+    id: string;
+    spaceid: string;
+    name: string;
+    sort: number;
+    dev: string;
+    prod: string;
+    inputs: {
+        id: string;
+        name: string;
+        type: string;
+    }[];
+    outputs: {
+        id: string;
+        name: string;
+        type: string;
+    }[];
+};
+export type Flow = {
+    id: string;
+    spaceid: string;
+    name: string;
+    sort: number;
+    dev: string;
+    prod: string;
+};
+export type ActiveFunc = {
+    id: string;
+    name: string;
+    inputs: {
+        id: string;
+        name: string;
+        type: string;
+    }[];
+    outputs: {
+        id: string;
+        name: string;
+        type: string;
+    }[];
+};
+export type ActiveFlow = {
+    id: string;
+    name: string;
+};
+export type Compute = {
+    spaces: {
+        [spaceid: string]: ComputeSpace;
+    };
+    funcs: {
+        [funcid: string]: Func;
+    };
+    flows: {
+        [flowid: string]: Flow;
+    };
+    activeFunc: ActiveFunc;
+    activeFlow: ActiveFlow;
+};
+export declare function initCompute(): Compute;

package/dist/state/data.d.ts

@@ -0,0 +1,31 @@
+export type DataSpace = {
+    id: string;
+    name: string;
+    sort: number;
+};
+export type Table = {
+    id: string;
+    spaceid: string;
+    name: string;
+    sort: number;
+    columns: {
+        id: string;
+        name: string;
+        type: string;
+        extend: string;
+    }[];
+    indexes: {
+        id: string;
+        columns: string[];
+        unique: boolean;
+    }[];
+};
+export type Data = {
+    spaces: {
+        [spaceid: string]: DataSpace;
+    };
+    tables: {
+        [tableid: string]: Table;
+    };
+};
+export declare function initData(): Data;

package/dist/state/index.d.ts

@@ -0,0 +1,7 @@
+export * from './app';
+export * from './base';
+export * from './compute';
+export * from './data';
+export * from './resource';
+export * from './runtime';
+export * from './state';

package/dist/state/resource.d.ts

@@ -0,0 +1,24 @@
+export interface DirEntry {
+    id: string;
+    name: string;
+    children: DirEntry[];
+}
+export interface ResourceEntry {
+    id: string;
+    dirid: string;
+    name: string;
+    sort: number;
+}
+export type ResourceSpace = {
+    id: string;
+    name: string;
+    sort: number;
+    dirTree: DirEntry;
+    resources: ResourceEntry[];
+};
+export type Resource = {
+    spaces: {
+        [spaceid: string]: ResourceSpace;
+    };
+};
+export declare function initResource(): Resource;

package/dist/state/runtime.d.ts

@@ -0,0 +1,16 @@
+import { ZProp } from 'x-runtime-lib';
+export type Prop = {
+    keys: string;
+    names: string[];
+    raw: ZProp;
+};
+export type Props = {
+    [key: string]: {
+        [tag: string]: Prop[];
+    };
+};
+export type Runtime = {
+    props: Props;
+};
+export declare function initRuntime(): Runtime;
+export declare function buildProps(): Props;

package/dist/state/state.d.ts

@@ -0,0 +1,15 @@
+import { App2 } from './app';
+import { Base } from './base';
+import { Compute } from './compute';
+import { Data } from './data';
+import { Resource } from './resource';
+import { Runtime } from './runtime';
+export type BlocklyState = {
+    base: Base;
+    runtime: Runtime;
+    app: App2;
+    compute: Compute;
+    data: Data;
+    resource: Resource;
+};
+export declare const blocklyState: BlocklyState;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "x-state-lib",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "vue-tsc && vite build",
+    "preview": "vite preview",
+    "lint": "eslint --fix --ignore-pattern dist/ --ignore-pattern public/ .",
+    "format": "prettier --write .",
+    "lint-staged": "lint-staged",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{vue,js,jsx,cjs,mjs,ts,tsx,cts,mts}": "eslint --fix --ignore-pattern dist/ --ignore-pattern public/ .",
+    "*": "prettier --write ."
+  },
+  "dependencies": {
+    "lodash-es": "^4.17.21",
+    "vue": "^3.5.12",
+    "vuetify": "^3.7.3",
+    "x-runtime-lib": "^0.5.18"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.7.7",
+    "@vitejs/plugin-vue": "^5.1.4",
+    "eslint": "^9.13.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-vue": "^9.29.1",
+    "husky": "^9.1.6",
+    "lint-staged": "^15.2.10",
+    "prettier": "3.3.3",
+    "sass": "^1.80.3",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.11.0",
+    "vite": "^5.4.9",
+    "vite-plugin-css-injected-by-js": "^3.5.2",
+    "vite-plugin-vuetify": "^2.0.4",
+    "vue-tsc": "^2.1.6"
+  }
+}