@meshagent/meshagent 0.13.0 → 0.15.0

package/dist/node/entrypoint.js

@@ -1,4 +1,9 @@
 "use strict";
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var _a, _b, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerXmlDocument = void 0;
 exports.applyBackendChanges = applyBackendChanges;
@@ -165,6 +170,14 @@ var appendTo = (dest, src) => {
     }
 };
 var from = Array.from;
+var every = (arr, f) => {
+    for (let i = 0; i < arr.length; i++) {
+        if (!f(arr[i], i, arr)) {
+            return false;
+        }
+    }
+    return true;
+};
 var some = (arr, f) => {
     for (let i = 0; i < arr.length; i++) {
         if (f(arr[i], i, arr)) {
@@ -173,6 +186,13 @@ var some = (arr, f) => {
     }
     return false;
 };
+var unfold = (len, f) => {
+    const array = new Array(len);
+    for (let i = 0; i < len; i++) {
+        array[i] = f(i, array);
+    }
+    return array;
+};
 var isArray = Array.isArray;
 var ObservableV2 = class {
     constructor() {
@@ -264,7 +284,7 @@ var toLowerCase = (s) => s.toLowerCase();
 var trimLeftRegex = /^\s*/g;
 var trimLeft = (s) => s.replace(trimLeftRegex, "");
 var fromCamelCaseRegex = /([A-Z])/g;
-var fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
+var fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match2) => `${separator}${toLowerCase(match2)}`));
 var _encodeUtf8Polyfill = (str) => {
     const encodedString = unescape(encodeURIComponent(str));
     const len = encodedString.length;
@@ -282,6 +302,7 @@ var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecode
 if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
     utf8TextDecoder = null;
 }
+var repeat = (source, n) => unfold(n, () => source).join("");
 var Encoder = class {
     constructor() {
         this.cpos = 0;
@@ -798,6 +819,9 @@ try {
 catch (e) {
 }
 var varStorage = _localStorage;
+var EqualityTraitSymbol = Symbol("Equality");
+var equals = (a, b) => a === b || a[EqualityTraitSymbol]?.(b) || false;
+var isObject = (o) => typeof o === "object";
 var assign = Object.assign;
 var keys = Object.keys;
 var forEach = (obj, f) => {
@@ -812,7 +836,7 @@ var isEmpty = (obj) => {
     }
     return true;
 };
-var every = (obj, f) => {
+var every2 = (obj, f) => {
     for (const key in obj) {
         if (!f(obj[key], key)) {
             return false;
@@ -821,7 +845,7 @@ var every = (obj, f) => {
     return true;
 };
 var hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-var equalFlat = (a, b) => a === b || size(a) === size(b) && every(a, (val, key) => (val !== void 0 || hasProperty(b, key)) && b[key] === val);
+var equalFlat = (a, b) => a === b || size(a) === size(b) && every2(a, (val, key) => (val !== void 0 || hasProperty(b, key)) && equals(b[key], val));
 var freeze = Object.freeze;
 var deepFreeze = (o) => {
     for (const key in o) {
@@ -845,6 +869,79 @@ var callAll = (fs, args2, i = 0) => {
     }
 };
 var id = (a) => a;
+var equalityDeep = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) {
+        return false;
+    }
+    if (a[EqualityTraitSymbol] != null) {
+        return a[EqualityTraitSymbol](b);
+    }
+    switch (a.constructor) {
+        case ArrayBuffer:
+            a = new Uint8Array(a);
+            b = new Uint8Array(b);
+        case Uint8Array: {
+            if (a.byteLength !== b.byteLength) {
+                return false;
+            }
+            for (let i = 0; i < a.length; i++) {
+                if (a[i] !== b[i]) {
+                    return false;
+                }
+            }
+            break;
+        }
+        case Set: {
+            if (a.size !== b.size) {
+                return false;
+            }
+            for (const value of a) {
+                if (!b.has(value)) {
+                    return false;
+                }
+            }
+            break;
+        }
+        case Map: {
+            if (a.size !== b.size) {
+                return false;
+            }
+            for (const key of a.keys()) {
+                if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+                    return false;
+                }
+            }
+            break;
+        }
+        case void 0:
+        case Object:
+            if (size(a) !== size(b)) {
+                return false;
+            }
+            for (const key in a) {
+                if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+                    return false;
+                }
+            }
+            break;
+        case Array:
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (let i = 0; i < a.length; i++) {
+                if (!equalityDeep(a[i], b[i])) {
+                    return false;
+                }
+            }
+            break;
+        default:
+            return false;
+    }
+    return true;
+};
 var isOneOf = (value, options) => options.includes(value);
 var isNode = typeof process !== "undefined" && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
 var isMac = typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
@@ -914,8 +1011,459 @@ var Pair = class {
     }
 };
 var create5 = (left, right) => new Pair(left, right);
+var bool = (gen) => gen.next() >= 0.5;
+var int53 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
+var int32 = (gen, min2, max2) => floor(gen.next() * (max2 + 1 - min2) + min2);
+var int31 = (gen, min2, max2) => int32(gen, min2, max2);
+var letter = (gen) => fromCharCode(int31(gen, 97, 122));
+var word = (gen, minLen = 0, maxLen = 20) => {
+    const len = int31(gen, minLen, maxLen);
+    let str = "";
+    for (let i = 0; i < len; i++) {
+        str += letter(gen);
+    }
+    return str;
+};
+var oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
+var schemaSymbol = Symbol("0schema");
+var ValidationError = class {
+    constructor() {
+        this._rerrs = [];
+    }
+    extend(path, expected, has, message = null) {
+        this._rerrs.push({ path, expected, has, message });
+    }
+    toString() {
+        const s = [];
+        for (let i = this._rerrs.length - 1; i > 0; i--) {
+            const r = this._rerrs[i];
+            s.push(repeat(" ", (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ""}${r.has} doesn't match ${r.expected}. ${r.message}`);
+        }
+        return s.join("\n");
+    }
+};
+var shapeExtends = (a, b) => {
+    if (a === b)
+        return true;
+    if (a == null || b == null || a.constructor !== b.constructor)
+        return false;
+    if (a[EqualityTraitSymbol])
+        return equals(a, b);
+    if (isArray(a)) {
+        return every(a, (aitem) => some(b, (bitem) => shapeExtends(aitem, bitem)));
+    }
+    else if (isObject(a)) {
+        return every2(a, (aitem, akey) => shapeExtends(aitem, b[akey]));
+    }
+    return false;
+};
+var Schema = (_a = class {
+        extends(other) {
+            let [a, b] = [
+                this.shape,
+                other.shape
+            ];
+            if (this.constructor._dilutes)
+                [b, a] = [a, b];
+            return shapeExtends(a, b);
+        }
+        equals(other) {
+            return this.constructor === other.constructor && equalityDeep(this.shape, other.shape);
+        }
+        [schemaSymbol]() {
+            return true;
+        }
+        [EqualityTraitSymbol](other) {
+            return this.equals(other);
+        }
+        validate(o) {
+            return this.check(o);
+        }
+        check(_o, _err) {
+            methodUnimplemented();
+        }
+        get nullable() {
+            return $union(this, $null);
+        }
+        get optional() {
+            return new $Optional(this);
+        }
+        cast(o) {
+            assert(o, this);
+            return (o);
+        }
+        expect(o) {
+            assert(o, this);
+            return o;
+        }
+    },
+    __setFunctionName(_a, "Schema"),
+    _a._dilutes = false,
+    _a);
+var $ConstructedBy = class extends Schema {
+    constructor(c, check) {
+        super();
+        this.shape = c;
+        this._c = check;
+    }
+    check(o, err = void 0) {
+        const c = o?.constructor === this.shape && (this._c == null || this._c(o));
+        !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? "Constructor match failed" : "Check failed");
+        return c;
+    }
+};
+var $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
+var $$constructedBy = $constructedBy($ConstructedBy);
+var $Custom = class extends Schema {
+    constructor(check) {
+        super();
+        this.shape = check;
+    }
+    check(o, err) {
+        const c = this.shape(o);
+        !c && err?.extend(null, "custom prop", o?.constructor.name, "failed to check custom prop");
+        return c;
+    }
+};
+var $custom = (check) => new $Custom(check);
+var $$custom = $constructedBy($Custom);
+var $Literal = class extends Schema {
+    constructor(literals) {
+        super();
+        this.shape = literals;
+    }
+    check(o, err) {
+        const c = this.shape.some((a) => a === o);
+        !c && err?.extend(null, this.shape.join(" | "), o.toString());
+        return c;
+    }
+};
+var $literal = (...literals) => new $Literal(literals);
+var $$literal = $constructedBy($Literal);
+var _regexEscape = (RegExp.escape ||
+    ((str) => str.replace(/[().|&,$^[\]]/g, (s) => "\\" + s)));
+var _schemaStringTemplateToRegex = (s) => {
+    if ($string.check(s)) {
+        return [_regexEscape(s)];
+    }
+    if ($$literal.check(s)) {
+        return (s.shape.map((v) => v + ""));
+    }
+    if ($$number.check(s)) {
+        return ["[+-]?\\d+.?\\d*"];
+    }
+    if ($$string.check(s)) {
+        return [".*"];
+    }
+    if ($$union.check(s)) {
+        return s.shape.map(_schemaStringTemplateToRegex).flat(1);
+    }
+    unexpectedCase();
+};
+var $StringTemplate = class extends Schema {
+    constructor(shape) {
+        super();
+        this.shape = shape;
+        this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `(${opts.join("|")})`).join("") + "$");
+    }
+    check(o, err) {
+        const c = this._r.exec(o) != null;
+        !c && err?.extend(null, this._r.toString(), o.toString(), "String doesn't match string template.");
+        return c;
+    }
+};
+var $$stringTemplate = $constructedBy($StringTemplate);
+var isOptionalSymbol = Symbol("optional");
+var $Optional = class extends Schema {
+    constructor(shape) {
+        super();
+        this.shape = shape;
+    }
+    check(o, err) {
+        const c = o === void 0 || this.shape.check(o);
+        !c && err?.extend(null, "undefined (optional)", "()");
+        return c;
+    }
+    get [isOptionalSymbol]() {
+        return true;
+    }
+};
+var $$optional = $constructedBy($Optional);
+var $Never = class extends Schema {
+    check(_o, err) {
+        err?.extend(null, "never", typeof _o);
+        return false;
+    }
+};
+var $never = new $Never();
+var $$never = $constructedBy($Never);
+var $Object = (_b = class _$Object extends Schema {
+        constructor(shape, partial = false) {
+            super();
+            this.shape = shape;
+            this._isPartial = partial;
+        }
+        get partial() {
+            return new _b(this.shape, true);
+        }
+        check(o, err) {
+            if (o == null) {
+                err?.extend(null, "object", "null");
+                return false;
+            }
+            return every2(this.shape, (vv, vk) => {
+                const c = this._isPartial && !hasProperty(o, vk) || vv.check(o[vk], err);
+                !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match");
+                return c;
+            });
+        }
+    },
+    _b._dilutes = true,
+    _b);
+var $object = (def) => (new $Object(def));
+var $$object = $constructedBy($Object);
+var $objectAny = $custom((o) => o != null && (o.constructor === Object || o.constructor == null));
+var $Record = class extends Schema {
+    constructor(keys2, values) {
+        super();
+        this.shape = {
+            keys: keys2,
+            values
+        };
+    }
+    check(o, err) {
+        return o != null && every2(o, (vv, vk) => {
+            const ck = this.shape.keys.check(vk, err);
+            !ck && err?.extend(vk + "", "Record", typeof o, ck ? "Key doesn't match schema" : "Value doesn't match value");
+            return ck && this.shape.values.check(vv, err);
+        });
+    }
+};
+var $record = (keys2, values) => new $Record(keys2, values);
+var $$record = $constructedBy($Record);
+var $Tuple = class extends Schema {
+    constructor(shape) {
+        super();
+        this.shape = shape;
+    }
+    check(o, err) {
+        return o != null && every2(this.shape, (vv, vk) => {
+            const c = (vv.check(o[vk], err));
+            !c && err?.extend(vk.toString(), "Tuple", typeof vv);
+            return c;
+        });
+    }
+};
+var $tuple = (...def) => new $Tuple(def);
+var $$tuple = $constructedBy($Tuple);
+var $Array = class extends Schema {
+    constructor(v) {
+        super();
+        this.shape = v.length === 1 ? v[0] : new $Union(v);
+    }
+    check(o, err) {
+        const c = isArray(o) && every(o, (oi) => this.shape.check(oi));
+        !c && err?.extend(null, "Array", "");
+        return c;
+    }
+};
+var $array = (...def) => new $Array(def);
+var $$array = $constructedBy($Array);
+var $arrayAny = $custom((o) => isArray(o));
+var $InstanceOf = class extends Schema {
+    constructor(constructor, check) {
+        super();
+        this.shape = constructor;
+        this._c = check;
+    }
+    check(o, err) {
+        const c = o instanceof this.shape && (this._c == null || this._c(o));
+        !c && err?.extend(null, this.shape.name, o?.constructor.name);
+        return c;
+    }
+};
+var $instanceOf = (c, check = null) => new $InstanceOf(c, check);
+var $$instanceOf = $constructedBy($InstanceOf);
+var $$schema = $instanceOf(Schema);
+var $Lambda = class extends Schema {
+    constructor(args2) {
+        super();
+        this.len = args2.length - 1;
+        this.args = $tuple(...args2.slice(-1));
+        this.res = args2[this.len];
+    }
+    check(f, err) {
+        const c = f.constructor === Function && f.length <= this.len;
+        !c && err?.extend(null, "function", typeof f);
+        return c;
+    }
+};
+var $$lambda = $constructedBy($Lambda);
+var $function = $custom((o) => typeof o === "function");
+var $Intersection = class extends Schema {
+    constructor(v) {
+        super();
+        this.shape = v;
+    }
+    check(o, err) {
+        const c = every(this.shape, (check) => check.check(o, err));
+        !c && err?.extend(null, "Intersectinon", typeof o);
+        return c;
+    }
+};
+var $$intersect = $constructedBy($Intersection, (o) => o.shape.length > 0);
+var $Union = (_d = class extends Schema {
+        constructor(v) {
+            super();
+            this.shape = v;
+        }
+        check(o, err) {
+            const c = some(this.shape, (vv) => vv.check(o, err));
+            err?.extend(null, "Union", typeof o);
+            return c;
+        }
+    },
+    __setFunctionName(_d, "$Union"),
+    _d._dilutes = true,
+    _d);
+var $union = (...schemas) => schemas.findIndex(($s) => $$union.check($s)) >= 0 ? $union(...schemas.map(($s) => $($s)).map(($s) => $$union.check($s) ? $s.shape : [$s]).flat(1)) : schemas.length === 1 ? schemas[0] : new $Union(schemas);
+var $$union = ($constructedBy($Union));
+var _t = () => true;
+var $any = $custom(_t);
+var $$any = ($constructedBy($Custom, (o) => o.shape === _t));
+var $bigint = $custom((o) => typeof o === "bigint");
+var $$bigint = ($custom((o) => o === $bigint));
+var $symbol = $custom((o) => typeof o === "symbol");
+var $$symbol = ($custom((o) => o === $symbol));
+var $number = $custom((o) => typeof o === "number");
+var $$number = ($custom((o) => o === $number));
+var $string = $custom((o) => typeof o === "string");
+var $$string = ($custom((o) => o === $string));
+var $boolean = $custom((o) => typeof o === "boolean");
+var $$boolean = ($custom((o) => o === $boolean));
+var $undefined = $literal(void 0);
+var $$undefined = ($constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0));
+var $void = $literal(void 0);
+var $null = $literal(null);
+var $$null = ($constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null));
+var $uint8Array = $constructedBy(Uint8Array);
+var $$uint8Array = ($constructedBy($ConstructedBy, (o) => o.shape === Uint8Array));
+var $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
+var $json = (() => {
+    const $jsonArr = ($array($any));
+    const $jsonRecord = ($record($string, $any));
+    const $json2 = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
+    $jsonArr.shape = $json2;
+    $jsonRecord.shape.values = $json2;
+    return $json2;
+})();
+var $ = (o) => {
+    if ($$schema.check(o)) {
+        return (o);
+    }
+    else if ($objectAny.check(o)) {
+        const o2 = {};
+        for (const k in o) {
+            o2[k] = $(o[k]);
+        }
+        return ($object(o2));
+    }
+    else if ($arrayAny.check(o)) {
+        return ($union(...o.map($)));
+    }
+    else if ($primitive.check(o)) {
+        return ($literal(o));
+    }
+    else if ($function.check(o)) {
+        return ($constructedBy(o));
+    }
+    unexpectedCase();
+};
+var assert = production ? () => {
+} : (o, schema) => {
+    const err = new ValidationError();
+    if (!schema.check(o, err)) {
+        throw create3(`Expected value to be of type ${schema.constructor.name}.
+${err.toString()}`);
+    }
+};
+var PatternMatcher = class {
+    constructor($state) {
+        this.patterns = [];
+        this.$state = $state;
+    }
+    if(pattern, handler) {
+        this.patterns.push({ if: $(pattern), h: handler });
+        return this;
+    }
+    else(h) {
+        return this.if($any, h);
+    }
+    done() {
+        return ((o, s) => {
+            for (let i = 0; i < this.patterns.length; i++) {
+                const p = this.patterns[i];
+                if (p.if.check(o)) {
+                    return p.h(o, s);
+                }
+            }
+            throw create3("Unhandled pattern");
+        });
+    }
+};
+var match = (state) => new PatternMatcher(state);
+var _random = (match($any).if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)).if($$string, (_o, gen) => word(gen)).if($$boolean, (_o, gen) => bool(gen)).if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER))).if($$union, (o, gen) => random(gen, oneOf(gen, o.shape))).if($$object, (o, gen) => {
+    const res = {};
+    for (const k in o.shape) {
+        let prop = o.shape[k];
+        if ($$optional.check(prop)) {
+            if (bool(gen)) {
+                continue;
+            }
+            prop = prop.shape;
+        }
+        res[k] = _random(prop, gen);
+    }
+    return res;
+}).if($$array, (o, gen) => {
+    const arr = [];
+    const n = int32(gen, 0, 42);
+    for (let i = 0; i < n; i++) {
+        arr.push(random(gen, o.shape));
+    }
+    return arr;
+}).if($$literal, (o, gen) => {
+    return oneOf(gen, o.shape);
+}).if($$null, (o, gen) => {
+    return null;
+}).if($$lambda, (o, gen) => {
+    const res = random(gen, o.res);
+    return () => res;
+}).if($$any, (o, gen) => random(gen, oneOf(gen, [
+    $number,
+    $string,
+    $null,
+    $undefined,
+    $bigint,
+    $boolean,
+    $array($number),
+    $record($union("a", "b", "c"), $number)
+]))).if($$record, (o, gen) => {
+    const res = {};
+    const keysN = int53(gen, 0, 3);
+    for (let i = 0; i < keysN; i++) {
+        const key = random(gen, o.shape.keys);
+        const val = random(gen, o.shape.values);
+        res[key] = val;
+    }
+    return res;
+}).done());
+var random = (gen, schema) => (_random($(schema), gen));
 var doc = (typeof document !== "undefined" ? document : {});
+var $fragment = $custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
 var domParser = (typeof DOMParser !== "undefined" ? new DOMParser() : null);
+var $element = $custom((el) => el.nodeType === ELEMENT_NODE);
+var $text = $custom((el) => el.nodeType === TEXT_NODE);
 var mapToStyleString = (m) => map(m, (value, key) => `${key}:${value};`).join("");
 var ELEMENT_NODE = doc.ELEMENT_NODE;
 var TEXT_NODE = doc.TEXT_NODE;
@@ -924,6 +1472,7 @@ var COMMENT_NODE = doc.COMMENT_NODE;
 var DOCUMENT_NODE = doc.DOCUMENT_NODE;
 var DOCUMENT_TYPE_NODE = doc.DOCUMENT_TYPE_NODE;
 var DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
+var $node = $custom((el) => el.nodeType === DOCUMENT_NODE);
 var create6 = Symbol;
 var BOLD = create6();
 var UNBOLD = create6();
@@ -4678,11 +5227,9 @@ var YXmlElement = class _YXmlElement extends YXmlFragment {
         const el = new _YXmlElement(this.nodeName);
         const attrs = this.getAttributes();
         forEach(attrs, (value, key) => {
-            if (typeof value === "string") {
-                el.setAttribute(key, value);
-            }
+            el.setAttribute(key, value);
         });
-        el.insert(0, this.toArray().map((item) => item instanceof AbstractType ? item.clone() : item));
+        el.insert(0, this.toArray().map((v) => v instanceof AbstractType ? v.clone() : v));
         return el;
     }
     toString() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.13.0",
+    "version": "0.15.0",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {