mol_schema 0.0.23 → 0.0.25

package/web.mjs

@@ -81,34 +81,36 @@ var $;
         static toString() {
             return $$.$mol_func_name(this);
         }
-        /** Type-guard that checks value by schema. */
-        static check(val) {
+        /** Type-predicate that checks value by schema. */
+        static check(value) {
             try {
-                this.guard(val);
+                this.guard(value);
                 return true;
             }
             catch (error) {
                 return false;
             }
         }
-        static [Symbol.hasInstance](val) {
-            return this.check(val);
+        /** `instanceof` support */
+        static [Symbol.hasInstance](value) {
+            return this.check(value);
         }
-        /** Strict parse. Fails of wrong values. */
+        /** Type-parser that fails of wrong values. */
         static guard(value) {
             return value;
         }
-        /** Relaxed cast. Normalizes wrong values. */
+        /** Type-caster that normalizes wrong values. */
         static cast(value) {
             try {
-                return this.guard(value);
+                this.guard(value);
+                return value;
             }
             catch (error) {
                 return this.default;
             }
         }
         /** Default value which conforms schema. */
-        static default = undefined;
+        static default = null;
     }
     $.$mol_schema_any = $mol_schema_any;
 })($ || ($ = {}));
@@ -568,7 +570,7 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_schema_instance = $mol_memo_key.func(function $mol_schema_instance(Class, ...args) {
+    $.$mol_schema_instance = $mol_memo_key.func(function $mol_schema_instance(Class) {
         class $mol_schema_instance_ extends $mol_schema_any {
             static Class = Class;
             static toString() {
@@ -581,9 +583,12 @@ var $;
                     return value;
                 return $mol_fail(new TypeError('Wrong class', { cause: { value, schema: this } }));
             }
-            static default = new Class(...args);
+            static cast(value) {
+                return this.guard(value);
+            }
+            static default;
         }
-        return ((Class[Symbol.hasInstance] === $mol_schema_any[Symbol.hasInstance])
+        return ((Class?.[Symbol.hasInstance] === $mol_schema_any[Symbol.hasInstance])
             ? Class
             : $mol_schema_instance_);
     });
@@ -591,31 +596,59 @@ var $;
 
 ;
 "use strict";
+var $;
+(function ($) {
+    function $mol_schema_lazy(Schema) {
+        // return $mol_delegate( $mol_schema_any, Schema )
+        return class $mol_schema_lazy_ extends $mol_schema_any {
+            static Schema = $mol_memo.func(Schema);
+            static guard(value) {
+                return this.Schema().guard(value);
+            }
+            static cast(value) {
+                return this.Schema().cast(value);
+            }
+            static get default() {
+                return this.Schema().default;
+            }
+        };
+    }
+    $.$mol_schema_lazy = $mol_schema_lazy;
+})($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_schema_every = $mol_memo_key.func(function $mol_schema_every(Schemas) {
-        return class $mol_schema_every_ extends $mol_schema_any {
-            static Schemas = Schemas;
+    $.$mol_schema_some = $mol_memo_key.func(function $mol_schema_some(Variants) {
+        return class $mol_schema_some_ extends $mol_schema_any {
+            static Variants = Variants;
             static toString() {
-                if (this !== $mol_schema_every_)
+                if (this !== $mol_schema_some_)
                     return super.toString();
-                return '$mol_schema_every<' + $mol_key(Schemas) + '>';
+                return '$mol_schema_some<' + $mol_key(Variants) + '>';
             }
             static guard(value) {
-                for (const Schema of Schemas) {
-                    Schema.guard(value);
+                const errors = [];
+                for (const Variant of Variants) {
+                    try {
+                        return Variant.guard(value);
+                    }
+                    catch (error) {
+                        errors.push(error);
+                    }
                 }
-                return value;
+                return $mol_fail(new AggregateError(errors, 'Wrong variant', { cause: { value, schema: this } }));
             }
             static cast(value) {
-                for (const Scheme of Schemas)
-                    value = Scheme.cast(value);
-                return value;
+                try {
+                    return this.guard(value);
+                }
+                catch (error) {
+                    return Variants[0].cast(value);
+                }
             }
-            static default = Schemas.find(Scheme => this.check(Scheme.default));
+            static default = Variants[0].default;
         };
     });
 })($ || ($ = {}));
@@ -624,56 +657,50 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_schema_range = $mol_memo_key.func(function $mol_schema_range(Range) {
-        return class $mol_schema_range_ extends $mol_schema_any {
-            static Range = Range;
+    $.$mol_schema_dict = $mol_memo_key.func(function $mol_schema_dict(Pair) {
+        return class $mol_schema_dict_ extends $mol_schema_any {
+            static Pair = Pair;
             static toString() {
-                if (this !== $mol_schema_range_)
+                if (this !== $mol_schema_dict_)
                     return super.toString();
-                return '$mol_schema_range<' + $mol_key(Range) + '>';
+                return '$mol_schema_dict<' + $mol_key(Pair) + '>';
             }
             static guard(value) {
-                if (typeof value !== 'number' && typeof value !== 'bigint')
-                    return $mol_fail(new TypeError('Uncomparable type', { cause: { value, schema: this } }));
-                if (!(value <= Range[1]))
-                    return $mol_fail(new TypeError('Too large', { cause: { value, schema: this } }));
-                if (!(value >= Range[0]))
-                    return $mol_fail(new TypeError('Too small', { cause: { value, schema: this } }));
+                if (Object.getPrototypeOf(Object.getPrototypeOf(value))) {
+                    return $mol_fail(new TypeError('Non dictionary', { cause: { value, schema: this } }));
+                }
+                for (const key in value) {
+                    try {
+                        Pair[0].guard(key);
+                    }
+                    catch (error) {
+                        return $mol_fail(new TypeError('Wrong key', { cause: { key, error, value, schema: this } }));
+                    }
+                    try {
+                        Pair[1].guard(value[key]);
+                    }
+                    catch (error) {
+                        return $mol_fail(new TypeError('Wrong val', { cause: { key, error, value, schema: this } }));
+                    }
+                }
                 return value;
             }
-            static cast(val) {
-                if (val > Range[1])
-                    return Range[1];
-                if (val >= Range[0])
-                    return val;
-                return Range[0];
+            static cast(value) {
+                if (Object.getPrototypeOf(Object.getPrototypeOf(value)))
+                    return this.default;
+                const res = {};
+                for (const key in value) {
+                    if (!Pair[0].check(key))
+                        continue;
+                    res[key] = Pair[1].cast(value[key]);
+                }
+                return res;
             }
-            static default = Range[0];
+            static default = {};
         };
     });
 })($ || ($ = {}));
 
-;
-"use strict";
-var $;
-(function ($) {
-    class $mol_schema_positive extends $mol_schema_range([0, Number.POSITIVE_INFINITY]) {
-    }
-    $.$mol_schema_positive = $mol_schema_positive;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    class $mol_schema_natural extends $mol_schema_every([
-        $mol_schema_integer,
-        $mol_schema_positive,
-    ]) {
-    }
-    $.$mol_schema_natural = $mol_schema_natural;
-})($ || ($ = {}));
-
 ;
 "use strict";
 var $;
@@ -689,11 +716,11 @@ var $;
             static guard(value) {
                 if (Options.some(Option => Object.is(Option, value)))
                     return value;
-                return $mol_fail(new TypeError('No one option', { cause: { value, schema: this } }));
+                return $mol_fail(new TypeError('Wrong option', { cause: { value, schema: this } }));
             }
-            static cast(val) {
-                if (this.check(val))
-                    return val;
+            static cast(value) {
+                if (this.check(value))
+                    return value;
                 return Options[0];
             }
             static default = Options[0];
@@ -705,44 +732,33 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    class $mol_schema_negative extends $mol_schema_range([Number.NEGATIVE_INFINITY, 0]) {
-    }
-    $.$mol_schema_negative = $mol_schema_negative;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    $.$mol_schema_some = $mol_memo_key.func(function $mol_schema_some(Variants) {
-        return class $mol_schema_some_ extends $mol_schema_any {
-            static Variants = Variants;
+    $.$mol_schema_list = $mol_memo_key.func(function $mol_schema_list(Item) {
+        return class $mol_schema_list_ extends $mol_schema_any {
+            static Item = Item;
             static toString() {
-                if (this !== $mol_schema_some_)
+                if (this !== $mol_schema_list_)
                     return super.toString();
-                return '$mol_schema_some<' + $mol_key(Variants) + '>';
+                return '$mol_schema_list<' + $mol_key(Item) + '>';
             }
             static guard(value) {
-                const errors = [];
-                for (const Variant of Variants) {
+                if (!Array.isArray(value))
+                    return $mol_fail(new TypeError('Non array', { cause: { value, schema: this } }));
+                for (const [index, item] of super.guard(value).entries()) {
                     try {
-                        return Variant.guard(value);
+                        Item.guard(item);
                     }
                     catch (error) {
-                        errors.push(error);
+                        return $mol_fail(new TypeError('Wrong item', { cause: { index, error, value, schema: this } }));
                     }
                 }
-                return $mol_fail(new AggregateError(errors, 'No one variant', { cause: { value, schema: this } }));
+                return value;
             }
             static cast(value) {
-                try {
-                    return this.guard(value);
-                }
-                catch (error) {
-                    return Variants[0].cast(value);
-                }
+                if (!Array.isArray(value))
+                    return this.default;
+                return value.map(item => Item.cast(item));
             }
-            static default = Variants[0].default;
+            static default = [];
         };
     });
 })($ || ($ = {}));
@@ -751,14 +767,43 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_schema_maybe = $mol_memo_key.func(function $mol_schema_maybe(Some) {
-        return class $mol_schema_maybe_ extends $mol_schema_some([$mol_schema_enum([undefined, null]), Some]) {
-            static Some = Some;
+    class $mol_schema_json extends $mol_schema_lazy(() => $mol_schema_some([
+        $mol_schema_dict([$mol_schema_string, $mol_schema_json]),
+        $mol_schema_enum([null]),
+        $mol_schema_boolean, $mol_schema_float, $mol_schema_string,
+        $mol_schema_list($mol_schema_json),
+    ])) {
+    }
+    $.$mol_schema_json = $mol_schema_json;
+})($ || ($ = {}));
+
+;
+"use strict";
+
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_schema_every = $mol_memo_key.func(function $mol_schema_every(Schemas) {
+        return class $mol_schema_every_ extends $mol_schema_any {
+            static Schemas = Schemas;
             static toString() {
-                if (this !== $mol_schema_maybe_)
+                if (this !== $mol_schema_every_)
                     return super.toString();
-                return '$mol_schema_maybe<' + $mol_key(Some) + '>';
+                return '$mol_schema_every<' + $mol_key(Schemas) + '>';
             }
+            static guard(value) {
+                for (const Schema of Schemas) {
+                    Schema.guard(value);
+                }
+                return value;
+            }
+            static cast(value) {
+                for (const Scheme of Schemas)
+                    value = Scheme.cast(value);
+                return value;
+            }
+            static default = Schemas.find(Scheme => this.check(Scheme.default));
         };
     });
 })($ || ($ = {}));
@@ -767,33 +812,31 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_schema_list = $mol_memo_key.func(function $mol_schema_list(Item) {
-        return class $mol_schema_list_ extends $mol_schema_any {
-            static Item = Item;
+    $.$mol_schema_range = $mol_memo_key.func(function $mol_schema_range(Range) {
+        return class $mol_schema_range_ extends $mol_schema_any {
+            static Range = Range;
             static toString() {
-                if (this !== $mol_schema_list_)
+                if (this !== $mol_schema_range_)
                     return super.toString();
-                return '$mol_schema_list<' + $mol_key(Item) + '>';
+                return '$mol_schema_range<' + $mol_key(Range) + '>';
             }
             static guard(value) {
-                if (!Array.isArray(value))
-                    return $mol_fail(new TypeError('Non array', { cause: { value, schema: this } }));
-                for (const [index, item] of super.guard(value).entries()) {
-                    try {
-                        Item.guard(item);
-                    }
-                    catch (error) {
-                        return $mol_fail(new TypeError('Wrong item', { cause: { index, error, value, schema: this } }));
-                    }
-                }
+                if (typeof value !== 'number' && typeof value !== 'bigint')
+                    return $mol_fail(new TypeError('Uncomparable type', { cause: { value, schema: this } }));
+                if (!(value <= Range[1]))
+                    return $mol_fail(new TypeError('Too large', { cause: { value, schema: this } }));
+                if (!(value >= Range[0]))
+                    return $mol_fail(new TypeError('Too small', { cause: { value, schema: this } }));
                 return value;
             }
             static cast(value) {
-                if (!Array.isArray(value))
-                    return this.default;
-                return value.map(item => Item.cast(item));
+                if (value > Range[1])
+                    return Range[1];
+                if (value >= Range[0])
+                    return value;
+                return Range[0];
             }
-            static default = [];
+            static default = Range[0];
         };
     });
 })($ || ($ = {}));
@@ -802,46 +845,50 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_schema_dict = $mol_memo_key.func(function $mol_schema_dict(Pair) {
-        return class $mol_schema_dict_ extends $mol_schema_any {
-            static Pair = Pair;
+    class $mol_schema_positive extends $mol_schema_range([0, Number.POSITIVE_INFINITY]) {
+    }
+    $.$mol_schema_positive = $mol_schema_positive;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_natural extends $mol_schema_every([
+        $mol_schema_integer,
+        $mol_schema_positive,
+    ]) {
+    }
+    $.$mol_schema_natural = $mol_schema_natural;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_negative extends $mol_schema_range([Number.NEGATIVE_INFINITY, 0]) {
+    }
+    $.$mol_schema_negative = $mol_schema_negative;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_schema_maybe = $mol_memo_key.func(function $mol_schema_maybe(Some) {
+        return class $mol_schema_maybe_ extends $mol_schema_any {
+            static Some = Some;
             static toString() {
-                if (this !== $mol_schema_dict_)
+                if (this !== $mol_schema_maybe_)
                     return super.toString();
-                return '$mol_schema_dict<' + $mol_key(Pair) + '>';
+                return '$mol_schema_maybe<' + $mol_key(Some) + '>';
             }
             static guard(value) {
-                if (Object.getPrototypeOf(Object.getPrototypeOf(value))) {
-                    return $mol_fail(new TypeError('Non dictionary', { cause: { value, schema: this } }));
-                }
-                for (const key in value) {
-                    try {
-                        Pair[0].guard(key);
-                    }
-                    catch (error) {
-                        return $mol_fail(new TypeError('Wrong key', { cause: { key, error, value, schema: this } }));
-                    }
-                    try {
-                        Pair[1].guard(value[key]);
-                    }
-                    catch (error) {
-                        return $mol_fail(new TypeError('Wrong val', { cause: { key, error, value, schema: this } }));
-                    }
-                }
-                return value;
-            }
-            static cast(value) {
-                if (Object.getPrototypeOf(Object.getPrototypeOf(value)))
-                    return this.default;
-                const res = {};
-                for (const key in value) {
-                    if (!Pair[0].check(key))
-                        continue;
-                    res[key] = Pair[1].cast(value[key]);
-                }
-                return res;
+                if (value == null)
+                    return value;
+                return Some.guard(value);
             }
-            static default = {};
+            static default = null;
         };
     });
 })($ || ($ = {}));

package/web.test.js

@@ -1152,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');
         }
@@ -1670,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.$$ = {}));
@@ -1739,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.$$ = {}));
@@ -1766,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.$$ = {}));
@@ -2030,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');
             },
@@ -2076,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');
             },
@@ -2098,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 $;