@acala-network/chopsticks-testing 0.9.1-2 → 0.9.1-3

package/dist/cjs/check.js

@@ -1,61 +1,116 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Checker_instances, _Checker_value, _Checker_pipeline, _Checker_format, _Checker_message, _Checker_redactOptions, _Checker_redact;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkHrmp = exports.checkUmp = exports.checkSystemEvents = exports.checkEvents = exports.check = exports.Checker = void 0;
-const vitest_1 = require("vitest");
-const processCodecOrArray = (codec, fn) => Array.isArray(codec) ? codec.map(fn) : fn(codec);
-const toHuman = (codec) => processCodecOrArray(codec, (c) => c?.toHuman?.() ?? c);
-const toHex = (codec) => processCodecOrArray(codec, (c) => c?.toHex?.() ?? c);
-const toJson = (codec) => processCodecOrArray(codec, (c) => c?.toJSON?.() ?? c);
-class Checker {
-    constructor(value, message) {
-        _Checker_instances.add(this);
-        _Checker_value.set(this, void 0);
-        _Checker_pipeline.set(this, []);
-        _Checker_format.set(this, 'json');
-        _Checker_message.set(this, void 0);
-        _Checker_redactOptions.set(this, void 0);
-        __classPrivateFieldSet(this, _Checker_value, value, "f");
-        __classPrivateFieldSet(this, _Checker_message, message, "f");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Checker: function() {
+        return Checker;
+    },
+    check: function() {
+        return check;
+    },
+    checkEvents: function() {
+        return checkEvents;
+    },
+    checkHrmp: function() {
+        return checkHrmp;
+    },
+    checkSystemEvents: function() {
+        return checkSystemEvents;
+    },
+    checkUmp: function() {
+        return checkUmp;
+    }
+});
+const _vitest = require("vitest");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
     }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+const processCodecOrArray = (codec, fn)=>Array.isArray(codec) ? codec.map(fn) : fn(codec);
+const toHuman = (codec)=>processCodecOrArray(codec, (c)=>c?.toHuman?.() ?? c);
+const toHex = (codec)=>processCodecOrArray(codec, (c)=>c?.toHex?.() ?? c);
+const toJson = (codec)=>processCodecOrArray(codec, (c)=>c?.toJSON?.() ?? c);
+var _value = /*#__PURE__*/ new WeakMap(), _pipeline = /*#__PURE__*/ new WeakMap(), _format = /*#__PURE__*/ new WeakMap(), _message = /*#__PURE__*/ new WeakMap(), _redactOptions = /*#__PURE__*/ new WeakMap(), _redact = /*#__PURE__*/ new WeakSet();
+class Checker {
     toHuman() {
-        __classPrivateFieldSet(this, _Checker_format, 'human', "f");
+        _class_private_field_set(this, _format, 'human');
         return this;
     }
     toHex() {
-        __classPrivateFieldSet(this, _Checker_format, 'hex', "f");
+        _class_private_field_set(this, _format, 'hex');
         return this;
     }
     toJson() {
-        __classPrivateFieldSet(this, _Checker_format, 'json', "f");
+        _class_private_field_set(this, _format, 'json');
         return this;
     }
     message(message) {
-        __classPrivateFieldSet(this, _Checker_message, message, "f");
+        _class_private_field_set(this, _message, message);
         return this;
     }
     filterEvents(...filters) {
         this.toHuman();
-        __classPrivateFieldGet(this, _Checker_pipeline, "f").push((value) => {
-            let data = value.map(({ event: { index: _, ...event } }) => event);
+        _class_private_field_get(this, _pipeline).push((value)=>{
+            let data = value.map(({ event: { index: _, ...event } })=>event);
             if (filters.length > 0) {
-                data = data.filter((evt) => {
-                    return filters.some((filter) => {
+                data = data.filter((evt)=>{
+                    return filters.some((filter)=>{
                         if (typeof filter === 'string') {
                             return evt.section === filter;
-                        }
-                        else if ('method' in filter) {
+                        } else if ('method' in filter) {
                             const { section, method } = filter;
                             return evt.section === section && evt.method === method;
                         }
@@ -66,23 +121,26 @@ class Checker {
         });
         return this;
     }
-    redact(options = { number: 2, hash: true }) {
-        __classPrivateFieldSet(this, _Checker_redactOptions, {
-            ...__classPrivateFieldGet(this, _Checker_redactOptions, "f"),
-            ...options,
-        }, "f");
+    redact(options = {
+        number: 2,
+        hash: true
+    }) {
+        _class_private_field_set(this, _redactOptions, {
+            ..._class_private_field_get(this, _redactOptions),
+            ...options
+        });
         return this;
     }
     map(fn) {
-        __classPrivateFieldGet(this, _Checker_pipeline, "f").push(fn);
+        _class_private_field_get(this, _pipeline).push(fn);
         return this;
     }
     pipe(fn) {
         return fn ? fn(this) : this;
     }
     async value() {
-        let value = await __classPrivateFieldGet(this, _Checker_value, "f");
-        switch (__classPrivateFieldGet(this, _Checker_format, "f")) {
+        let value = await _class_private_field_get(this, _value);
+        switch(_class_private_field_get(this, _format)){
             case 'human':
                 value = toHuman(value);
                 break;
@@ -93,31 +151,51 @@ class Checker {
                 value = toJson(value);
                 break;
         }
-        for (const fn of __classPrivateFieldGet(this, _Checker_pipeline, "f")) {
+        for (const fn of _class_private_field_get(this, _pipeline)){
             value = await fn(value);
         }
-        value = __classPrivateFieldGet(this, _Checker_instances, "m", _Checker_redact).call(this, value);
+        value = _class_private_method_get(this, _redact, redact).call(this, value);
         return value;
     }
     async toMatchSnapshot(msg) {
-        return (0, vitest_1.expect)(await this.value()).toMatchSnapshot(msg ?? __classPrivateFieldGet(this, _Checker_message, "f"));
+        return (0, _vitest.expect)(await this.value()).toMatchSnapshot(msg ?? _class_private_field_get(this, _message));
+    }
+    constructor(value, message){
+        _class_private_method_init(this, _redact);
+        _class_private_field_init(this, _value, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _pipeline, {
+            writable: true,
+            value: []
+        });
+        _class_private_field_init(this, _format, {
+            writable: true,
+            value: 'json'
+        });
+        _class_private_field_init(this, _message, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _redactOptions, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _value, value);
+        _class_private_field_set(this, _message, message);
     }
 }
-exports.Checker = Checker;
-_Checker_value = new WeakMap(), _Checker_pipeline = new WeakMap(), _Checker_format = new WeakMap(), _Checker_message = new WeakMap(), _Checker_redactOptions = new WeakMap(), _Checker_instances = new WeakSet(), _Checker_redact = function _Checker_redact(value) {
-    if (!__classPrivateFieldGet(this, _Checker_redactOptions, "f")) {
+function redact(value) {
+    if (!_class_private_field_get(this, _redactOptions)) {
         return value;
     }
-    const redactNumber = __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === true || typeof __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === 'number';
-    const precision = redactNumber
-        ? typeof __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === 'number'
-            ? __classPrivateFieldGet(this, _Checker_redactOptions, "f").number
-            : 0
-        : 0;
-    const redactHash = __classPrivateFieldGet(this, _Checker_redactOptions, "f").hash === true;
-    const redactHex = __classPrivateFieldGet(this, _Checker_redactOptions, "f").hex === true;
-    const redactAddress = __classPrivateFieldGet(this, _Checker_redactOptions, "f").address === true;
-    const processNumber = (value) => {
+    const redactNumber = _class_private_field_get(this, _redactOptions).number === true || typeof _class_private_field_get(this, _redactOptions).number === 'number';
+    const precision = redactNumber ? typeof _class_private_field_get(this, _redactOptions).number === 'number' ? _class_private_field_get(this, _redactOptions).number : 0 : 0;
+    const redactHash = _class_private_field_get(this, _redactOptions).hash === true;
+    const redactHex = _class_private_field_get(this, _redactOptions).hex === true;
+    const redactAddress = _class_private_field_get(this, _redactOptions).address === true;
+    const processNumber = (value)=>{
         if (precision > 0) {
             const rounded = parseFloat(value.toPrecision(precision));
             if (rounded === value) {
@@ -127,7 +205,7 @@ _Checker_value = new WeakMap(), _Checker_pipeline = new WeakMap(), _Checker_form
         }
         return '(number)';
     };
-    const process = (obj) => {
+    const process = (obj)=>{
         if (obj == null) {
             return obj;
         }
@@ -159,13 +237,16 @@ _Checker_value = new WeakMap(), _Checker_pipeline = new WeakMap(), _Checker_form
             return obj;
         }
         if (typeof obj === 'object') {
-            return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, process(v)]));
+            return Object.fromEntries(Object.entries(obj).map(([k, v])=>[
+                    k,
+                    process(v)
+                ]));
         }
         return obj;
     };
     return process(value);
-};
-const check = (value, msg) => {
+}
+const check = (value, msg)=>{
     if (value instanceof Checker) {
         if (msg) {
             return value.message(msg);
@@ -174,19 +255,10 @@ const check = (value, msg) => {
     }
     return new Checker(value, msg);
 };
-exports.check = check;
-const checkEvents = ({ events }, ...filters) => (0, exports.check)(events, 'events')
-    .filterEvents(...filters)
-    .redact();
-exports.checkEvents = checkEvents;
-const checkSystemEvents = ({ api }, ...filters) => (0, exports.check)(api.query.system.events(), 'system events')
-    .filterEvents(...filters)
-    .redact();
-exports.checkSystemEvents = checkSystemEvents;
-const checkUmp = ({ api }) => (0, exports.check)(api.query.parachainSystem.upwardMessages(), 'ump').map((value) => api.createType('Vec<XcmVersionedXcm>', value).toJSON());
-exports.checkUmp = checkUmp;
-const checkHrmp = ({ api }) => (0, exports.check)(api.query.parachainSystem.hrmpOutboundMessages(), 'hrmp').map((value) => value.map(({ recipient, data }) => ({
-    data: api.createType('(XcmpMessageFormat, XcmVersionedXcm)', data),
-    recipient,
-})));
-exports.checkHrmp = checkHrmp;
+const checkEvents = ({ events }, ...filters)=>check(events, 'events').filterEvents(...filters).redact();
+const checkSystemEvents = ({ api }, ...filters)=>check(api.query.system.events(), 'system events').filterEvents(...filters).redact();
+const checkUmp = ({ api })=>check(api.query.parachainSystem.upwardMessages(), 'ump').map((value)=>api.createType('Vec<XcmVersionedXcm>', value).toJSON());
+const checkHrmp = ({ api })=>check(api.query.parachainSystem.hrmpOutboundMessages(), 'hrmp').map((value)=>value.map(({ recipient, data })=>({
+                data: api.createType('(XcmpMessageFormat, XcmVersionedXcm)', data),
+                recipient
+            })));