mol_schema 0.0.22 → 0.0.24

package/web.test.js

@@ -14,16 +14,6 @@ var $;
     $.$mol_promise_like = $mol_promise_like;
 })($ || ($ = {}));
 
-;
-"use strict";
-var $;
-(function ($) {
-    function $mol_fail_hidden(error) {
-        throw error; /// Use 'Never Pause Here' breakpoint in DevTools or simply blackbox this script
-    }
-    $.$mol_fail_hidden = $mol_fail_hidden;
-})($ || ($ = {}));
-
 ;
 "use strict";
 var $;
@@ -1162,12 +1152,18 @@ var $;
         'color': 'gray',
     });
     $.$mol_dev_format_indent = $.$mol_dev_format_div.bind(null, {
-        'margin-left': '13px'
+        'margin-inline-start': '13px'
     });
     class Stack extends Array {
         // [ Symbol.toPrimitive ]() {
         // 	return this.toString()
         // }
+        match(...args) {
+            return this.toString().match(...args);
+        }
+        split(...args) {
+            return this.toString().split(...args);
+        }
         toString() {
             return this.join('\n');
         }
@@ -1366,6 +1362,72 @@ var $;
     });
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($) {
+    $mol_test({
+        'get'() {
+            const proxy = $mol_delegate({}, () => ({ foo: 777 }));
+            $mol_assert_equal(proxy.foo, 777);
+        },
+        'has'() {
+            const proxy = $mol_delegate({}, () => ({ foo: 777 }));
+            $mol_assert_equal('foo' in proxy, true);
+        },
+        'set'() {
+            const target = { foo: 777 };
+            const proxy = $mol_delegate({}, () => target);
+            proxy.foo = 123;
+            $mol_assert_equal(target.foo, 123);
+        },
+        'getOwnPropertyDescriptor'() {
+            const proxy = $mol_delegate({}, () => ({ foo: 777 }));
+            $mol_assert_like(Object.getOwnPropertyDescriptor(proxy, 'foo'), {
+                value: 777,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        },
+        'ownKeys'() {
+            const proxy = $mol_delegate({}, () => ({ foo: 777, [Symbol.toStringTag]: 'bar' }));
+            $mol_assert_like(Reflect.ownKeys(proxy), ['foo', Symbol.toStringTag]);
+        },
+        'getPrototypeOf'() {
+            class Foo {
+            }
+            const proxy = $mol_delegate({}, () => new Foo);
+            $mol_assert_equal(Object.getPrototypeOf(proxy), Foo.prototype);
+        },
+        'setPrototypeOf'() {
+            class Foo {
+            }
+            const target = {};
+            const proxy = $mol_delegate({}, () => target);
+            Object.setPrototypeOf(proxy, Foo.prototype);
+            $mol_assert_equal(Object.getPrototypeOf(target), Foo.prototype);
+        },
+        'instanceof'() {
+            class Foo {
+            }
+            const proxy = $mol_delegate({}, () => new Foo);
+            $mol_assert_ok(proxy instanceof Foo);
+            $mol_assert_ok(proxy instanceof $mol_delegate);
+        },
+        'autobind'() {
+            class Foo {
+            }
+            const proxy = $mol_delegate({}, () => new Foo);
+            $mol_assert_ok(proxy instanceof Foo);
+            $mol_assert_ok(proxy instanceof $mol_delegate);
+        },
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+
 ;
 "use strict";
 var $;
@@ -1380,6 +1442,149 @@ var $;
     });
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($) {
+    $mol_test({
+        'run callback'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            $mol_assert_equal(Plus1.run(() => 2), 3);
+        },
+        'wrap function'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            const obj = {
+                level: 2,
+                pow: Plus1.func(function (a) {
+                    return a ** this.level;
+                })
+            };
+            $mol_assert_equal(obj.pow(2), 5);
+        },
+        'decorate field getter'() {
+            class Plus1 extends $mol_wrapper {
+                static last = 0;
+                static wrap(task) {
+                    return function (...args) {
+                        return Plus1.last = (task.call(this, ...args) || 0) + 1;
+                    };
+                }
+            }
+            class Foo {
+                static get two() {
+                    return 1;
+                }
+                static set two(next) { }
+            }
+            __decorate([
+                Plus1.field
+            ], Foo, "two", null);
+            $mol_assert_equal(Foo.two, 2);
+            Foo.two = 3;
+            $mol_assert_equal(Plus1.last, 2);
+            $mol_assert_equal(Foo.two, 2);
+        },
+        'decorate instance method'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            class Foo1 {
+                level = 2;
+                pow(a) {
+                    return a ** this.level;
+                }
+            }
+            __decorate([
+                Plus1.method
+            ], Foo1.prototype, "pow", null);
+            const Foo2 = Foo1;
+            const foo = new Foo2;
+            $mol_assert_equal(foo.pow(2), 5);
+        },
+        'decorate static method'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            class Foo {
+                static level = 2;
+                static pow(a) {
+                    return a ** this.level;
+                }
+            }
+            __decorate([
+                Plus1.method
+            ], Foo, "pow", null);
+            $mol_assert_equal(Foo.pow(2), 5);
+        },
+        'decorate class'() {
+            class BarInc extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        const foo = task.call(this, ...args);
+                        foo.bar++;
+                        return foo;
+                    };
+                }
+            }
+            let Foo = class Foo {
+                bar;
+                constructor(bar) {
+                    this.bar = bar;
+                }
+            };
+            Foo = __decorate([
+                BarInc.class
+            ], Foo);
+            $mol_assert_equal(new Foo(2).bar, 3);
+        },
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $mol_test({
+        'memoize field'() {
+            class Foo {
+                static one = 1;
+                static get two() {
+                    return ++this.one;
+                }
+                static set two(next) { }
+            }
+            __decorate([
+                $mol_memo.field
+            ], Foo, "two", null);
+            $mol_assert_equal(Foo.two, 2);
+            $mol_assert_equal(Foo.two, 2);
+            Foo.two = 3;
+            $mol_assert_equal(Foo.two, 3);
+            $mol_assert_equal(Foo.two, 3);
+        },
+    });
+})($ || ($ = {}));
+
 ;
 "use strict";
 /** @jsx $mol_jsx */
@@ -1455,6 +1660,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of enum schema"($) {
+                $mol_assert_equal($mol_schema_enum(['foo']), $mol_schema_enum(['foo']));
+                $mol_assert_unique($mol_schema_enum(['foo']), $mol_schema_enum(['bar']));
+            },
             "Enum options"($) {
                 const Config = $mol_schema_enum([123, 'foo']);
                 $mol_assert_equal('$mol_schema_enum<[123,"foo"]>', Config + '', $mol_key(Config));
@@ -1467,7 +1676,7 @@ var $;
                 $mol_assert_equal(Config.cast('foo'), 'foo');
                 $mol_assert_equal(Config.cast('bar'), 123);
                 $mol_assert_equal(123, Config.guard(123));
-                $mol_assert_fail(() => Config.guard(321), 'No one option');
+                $mol_assert_fail(() => Config.guard(321), 'Wrong option');
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));
@@ -1522,6 +1731,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of some schema"($) {
+                $mol_assert_equal($mol_schema_some([$mol_schema_float]), $mol_schema_some([$mol_schema_float]));
+                $mol_assert_unique($mol_schema_some([$mol_schema_float]), $mol_schema_some([$mol_schema_string]));
+            },
             "Some variant"($) {
                 const Config = $mol_schema_some([$mol_schema_float, $mol_schema_string]);
                 $mol_assert_equal('$mol_schema_some<[$mol_schema_float,$mol_schema_string]>', Config + '');
@@ -1532,7 +1745,7 @@ var $;
                 $mol_assert_equal('foo', Config.cast('foo'));
                 $mol_assert_equal(Number.NaN, Config.cast(true));
                 $mol_assert_equal(123, Config.guard(123));
-                $mol_assert_fail(() => Config.guard(false), 'No one variant');
+                $mol_assert_fail(() => Config.guard(false), 'Wrong variant');
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));
@@ -1545,6 +1758,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of maybe schema"($) {
+                $mol_assert_equal($mol_schema_maybe($mol_schema_float), $mol_schema_maybe($mol_schema_float));
+                $mol_assert_unique($mol_schema_maybe($mol_schema_float), $mol_schema_maybe($mol_schema_string));
+            },
             "Optional value"($) {
                 const Config = $mol_schema_maybe($mol_schema_string);
                 $mol_assert_equal('$mol_schema_maybe<$mol_schema_string>', Config + '');
@@ -1555,9 +1772,9 @@ var $;
                 $mol_assert_equal('foo', Config.cast('foo'));
                 $mol_assert_equal(undefined, Config.cast(undefined));
                 $mol_assert_equal(null, Config.cast(null));
-                $mol_assert_equal(undefined, Config.cast(0));
+                $mol_assert_equal(null, Config.cast(0));
                 $mol_assert_equal('foo', Config.guard('foo'));
-                $mol_assert_fail(() => Config.guard(123), 'No one variant');
+                $mol_assert_fail(() => Config.guard(123), 'Wrong type');
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));
@@ -1600,8 +1817,12 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of range schema"($) {
+                $mol_assert_equal($mol_schema_range([0, 1]), $mol_schema_range([0, 1]));
+                $mol_assert_unique($mol_schema_range([0, 1]), $mol_schema_range([0, 2]));
+            },
             "Float range schema"($) {
-                const Range = $mol_schema_range(4, 8);
+                const Range = $mol_schema_range([4, 8]);
                 $mol_assert_equal(true, Range.check(5.5));
                 $mol_assert_equal(true, Range.check(4));
                 $mol_assert_equal(true, Range.check(8));
@@ -1626,9 +1847,13 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of every schema"($) {
+                $mol_assert_equal($mol_schema_every([$mol_schema_float]), $mol_schema_every([$mol_schema_float]));
+                $mol_assert_unique($mol_schema_every([$mol_schema_float]), $mol_schema_every([$mol_schema_string]));
+            },
             "Range intersection"($) {
-                const Narrow = $mol_schema_every([$mol_schema_integer, $mol_schema_range(1, 8), $mol_schema_range(4, 10)]);
-                $mol_assert_equal('$mol_schema_every<[$mol_schema_integer,$mol_schema_range<1,8>,$mol_schema_range<4,10>]>', Narrow + '');
+                const Narrow = $mol_schema_every([$mol_schema_integer, $mol_schema_range([1, 8]), $mol_schema_range([4, 10])]);
+                $mol_assert_equal('$mol_schema_every<[$mol_schema_integer,$mol_schema_range<[1,8]>,$mol_schema_range<[4,10]>]>', Narrow + '');
                 $mol_assert_equal(true, Narrow.check(6));
                 $mol_assert_equal(true, Narrow.check(4));
                 $mol_assert_equal(true, Narrow.check(8));
@@ -1654,6 +1879,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of list schema"($) {
+                $mol_assert_equal($mol_schema_list($mol_schema_float), $mol_schema_list($mol_schema_float));
+                $mol_assert_unique($mol_schema_list($mol_schema_float), $mol_schema_list($mol_schema_string));
+            },
             "Array schema"($) {
                 const Vector = $mol_schema_list($mol_schema_float);
                 $mol_assert_equal('$mol_schema_list<$mol_schema_float>', Vector + '');
@@ -1678,6 +1907,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of pattern schema"($) {
+                $mol_assert_equal($mol_schema_pattern(/foo/), $mol_schema_pattern(/foo/));
+                $mol_assert_unique($mol_schema_pattern(/foo/), $mol_schema_pattern(/bar/));
+            },
             "String pattern schema"($) {
                 const Email = $mol_schema_pattern(/^.*@.*$/);
                 $mol_assert_equal('$mol_schema_pattern</^.*@.*$/>', Email + '', $mol_key(Email));
@@ -1721,8 +1954,12 @@ var $;
 var $;
 (function ($_1) {
     $mol_test({
+        "Cache of dict schema"($) {
+            $mol_assert_equal($mol_schema_dict([$mol_schema_string, $mol_schema_float]), $mol_schema_dict([$mol_schema_string, $mol_schema_float]));
+            $mol_assert_unique($mol_schema_dict([$mol_schema_string, $mol_schema_float]), $mol_schema_dict([$mol_schema_string, $mol_schema_string]));
+        },
         "Dictionary schema"($) {
-            const Flags = $mol_schema_dict($mol_schema_pattern(/^[a-z]+$/), $mol_schema_boolean);
+            const Flags = $mol_schema_dict([$mol_schema_pattern(/^[a-z]+$/), $mol_schema_boolean]);
             $mol_assert_equal(true, Flags.check({}));
             $mol_assert_equal(true, Flags.check({ foo: false }));
             $mol_assert_equal(false, Flags.check({ f00: false }));
@@ -1745,6 +1982,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of record schema"($) {
+                $mol_assert_equal($mol_schema_record({ foo: $mol_schema_float }), $mol_schema_record({ foo: $mol_schema_float }));
+                $mol_assert_unique($mol_schema_record({ foo: $mol_schema_float }), $mol_schema_record({ foo: $mol_schema_string }));
+            },
             "Record schema"($) {
                 const User = $mol_schema_record({
                     name: $mol_schema_string,
@@ -1795,7 +2036,7 @@ var $;
                 });
                 $mol_assert_equal(true, User.check({ name: 'foo', age: 123 }));
                 $mol_assert_equal(true, User.check({ name: null }));
-                $mol_assert_equal({ name: 'foo', age: undefined }, User.cast({ name: 'foo', age: false }));
+                $mol_assert_equal({ name: 'foo', age: null }, User.cast({ name: 'foo', age: false }));
                 $mol_assert_equal({ name: 'foo', age: undefined }, User.guard({ name: 'foo', age: undefined }));
                 $mol_assert_fail(() => User.guard({ name: 'foo', age: 'bar' }), 'Wrong field');
             },
@@ -1830,6 +2071,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of instance schema"($) {
+                $mol_assert_equal($mol_schema_instance(Uint8Array), $mol_schema_instance(Uint8Array));
+                $mol_assert_unique($mol_schema_instance(Uint8Array), $mol_schema_instance(Int8Array));
+            },
             "Class instance schema"($) {
                 const Blob = $mol_schema_instance(Uint8Array);
                 $mol_assert_equal('$mol_schema_instance<Uint8Array>', Blob + '', $mol_key(Blob));
@@ -1837,7 +2082,7 @@ var $;
                 $mol_assert_equal(false, Blob.check(new Int8Array));
                 $mol_assert_equal(false, Blob.check(null));
                 $mol_assert_equal(new Uint8Array([0, 1]), Blob.cast(new Uint8Array([0, 1])));
-                $mol_assert_equal(new Uint8Array, Blob.cast(new Int8Array([1, -1])));
+                $mol_assert_fail(() => Blob.cast(new Int8Array), 'Wrong class');
                 $mol_assert_equal(new Uint8Array, Blob.guard(new Uint8Array));
                 $mol_assert_fail(() => Blob.guard(new Int8Array), 'Wrong class');
             },
@@ -1859,6 +2104,55 @@ var $;
     })($$ = $_1.$$ || ($_1.$$ = {}));
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($_1) {
+    var $$;
+    (function ($$) {
+        $mol_test({
+            "Integers as recursive Sets"($) {
+                class Schema extends $mol_schema_lazy(() => $mol_schema_list(Schema)) {
+                }
+                $mol_assert_equal(Schema.default, []);
+                $mol_assert_equal(Schema.check([]), true);
+                $mol_assert_equal(Schema.check(''), false);
+                $mol_assert_equal(Schema.guard([]), []);
+                $mol_assert_fail(() => Schema.guard(''), 'Non array');
+                $mol_assert_equal(Schema.cast([]), []);
+                $mol_assert_equal(Schema.cast(''), []);
+            },
+        });
+    })($$ = $_1.$$ || ($_1.$$ = {}));
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($_1) {
+    var $$;
+    (function ($$) {
+        $mol_test({
+            "JSON schema"($) {
+                $mol_assert_equal('$mol_schema_json', $mol_schema_json + '', $mol_key($mol_schema_json));
+                $mol_assert_equal(true, $mol_schema_json.check(null));
+                $mol_assert_equal(true, $mol_schema_json.check(0));
+                $mol_assert_equal(true, $mol_schema_json.check(false));
+                $mol_assert_equal(true, $mol_schema_json.check(''));
+                $mol_assert_equal(true, $mol_schema_json.check([]));
+                $mol_assert_equal(true, $mol_schema_json.check({}));
+                $mol_assert_equal(false, $mol_schema_json.check(undefined));
+                $mol_assert_equal(false, $mol_schema_json.check(new Date));
+                $mol_assert_equal(false, $mol_schema_json.check({ __proto__: {} }));
+                $mol_assert_equal({}, $mol_schema_json.cast(new Date));
+                $mol_assert_equal({ foo: 777, bar: {} }, $mol_schema_json.cast({ foo: 777, bar: new Date }));
+                $mol_assert_equal({ foo: [null, 0, false, ''] }, $mol_schema_json.guard({ foo: [null, 0, false, ''] }));
+                $mol_assert_fail(() => $mol_schema_json.guard({ foo: [new Date] }), 'Wrong variant');
+            },
+        });
+    })($$ = $_1.$$ || ($_1.$$ = {}));
+})($ || ($ = {}));
+
 ;
 "use strict";
 var $;
@@ -1952,7 +2246,7 @@ var $;
                 } + '', class Some extends $mol_schema_maybe($mol_schema_float) {
                 } + '', class Some extends $mol_schema_every([$mol_schema_float]) {
                 } + '', class Some extends $mol_schema_list($mol_schema_float) {
-                } + '', class Some extends $mol_schema_dict($mol_schema_string, $mol_schema_string) {
+                } + '', class Some extends $mol_schema_dict([$mol_schema_string, $mol_schema_string]) {
                 } + '', class Some extends $mol_schema_record({ name: $mol_schema_string }) {
                 } + '', class Some extends $mol_schema_partial({ name: $mol_schema_string }) {
                 } + '');