mol_schema 0.0.21 → 0.0.23

package/node.js

@@ -91,6 +91,9 @@ var $;
                 return false;
             }
         }
+        static [Symbol.hasInstance](val) {
+            return this.check(val);
+        }
         /** Strict parse. Fails of wrong values. */
         static guard(value) {
             return value;
@@ -120,6 +123,60 @@ var $;
     $.$mol_fail = $mol_fail;
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_float extends $mol_schema_any {
+        static guard(value) {
+            if (typeof value === 'number')
+                return value;
+            return $mol_fail(new TypeError('Wrong type', { cause: { value, schema: this } }));
+        }
+        static default = Number.NaN;
+    }
+    $.$mol_schema_float = $mol_schema_float;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_integer extends $mol_schema_float {
+        $mol_schema_integer = true;
+        static guard(value) {
+            const val = super.guard(value);
+            if (!Number.isFinite(val))
+                return $mol_fail(new TypeError('Non finite', { cause: { value, schema: this } }));
+            if (Math.trunc(val) !== val)
+                return $mol_fail(new TypeError('Non integer', { cause: { value, schema: this } }));
+            return val;
+        }
+        static default = 0;
+    }
+    $.$mol_schema_integer = $mol_schema_integer;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_bigint extends $mol_schema_any {
+        static guard(value) {
+            if (typeof value === 'bigint')
+                return value;
+            return $mol_fail(new TypeError('Wrong type', { cause: { value, schema: this } }));
+        }
+        static cast(value) {
+            if (typeof value === 'number')
+                return BigInt($mol_schema_integer.cast(value));
+            return super.cast(value);
+        }
+        static default = 0n;
+    }
+    $.$mol_schema_bigint = $mol_schema_bigint;
+})($ || ($ = {}));
+
 ;
 "use strict";
 var $;
@@ -153,6 +210,241 @@ var $;
     $.$mol_schema_string = $mol_schema_string;
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_ambient_ref = Symbol('$mol_ambient_ref');
+    function $mol_ambient(overrides) {
+        return Object.setPrototypeOf(overrides, this || $);
+    }
+    $.$mol_ambient = $mol_ambient;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    const instances = new WeakSet();
+    /**
+     * Proxy that delegates all to lazy returned target.
+     *
+     * 	$mol_delegate( Array.prototype , ()=> fetch_array() )
+     */
+    function $mol_delegate(proto, target) {
+        const proxy = new Proxy(proto, {
+            get: (_, field) => {
+                const obj = target();
+                let val = Reflect.get(obj, field);
+                if (typeof val === 'function') {
+                    val = val.bind(obj);
+                }
+                return val;
+            },
+            has: (_, field) => Reflect.has(target(), field),
+            set: (_, field, value) => Reflect.set(target(), field, value),
+            getOwnPropertyDescriptor: (_, field) => Reflect.getOwnPropertyDescriptor(target(), field),
+            ownKeys: () => Reflect.ownKeys(target()),
+            getPrototypeOf: () => Reflect.getPrototypeOf(target()),
+            setPrototypeOf: (_, donor) => Reflect.setPrototypeOf(target(), donor),
+            isExtensible: () => Reflect.isExtensible(target()),
+            preventExtensions: () => Reflect.preventExtensions(target()),
+            apply: (_, self, args) => Reflect.apply(target(), self, args),
+            construct: (_, args, retarget) => Reflect.construct(target(), args, retarget),
+            defineProperty: (_, field, descr) => Reflect.defineProperty(target(), field, descr),
+            deleteProperty: (_, field) => Reflect.deleteProperty(target(), field),
+        });
+        instances.add(proxy);
+        return proxy;
+    }
+    $.$mol_delegate = $mol_delegate;
+    Reflect.defineProperty($mol_delegate, Symbol.hasInstance, {
+        value: (obj) => instances.has(obj),
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_owning_map = new WeakMap();
+    function $mol_owning_allow(having) {
+        try {
+            if (!having)
+                return false;
+            if (typeof having !== 'object' && typeof having !== 'function')
+                return false;
+            if (having instanceof $mol_delegate)
+                return false;
+            if (typeof having['destructor'] !== 'function')
+                return false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    $.$mol_owning_allow = $mol_owning_allow;
+    function $mol_owning_get(having, Owner) {
+        if (!$mol_owning_allow(having))
+            return null;
+        while (true) {
+            const owner = $.$mol_owning_map.get(having);
+            if (!owner)
+                return owner;
+            if (!Owner)
+                return owner;
+            if (owner instanceof Owner)
+                return owner;
+            having = owner;
+        }
+    }
+    $.$mol_owning_get = $mol_owning_get;
+    function $mol_owning_check(owner, having) {
+        if (!$mol_owning_allow(having))
+            return false;
+        if ($.$mol_owning_map.get(having) !== owner)
+            return false;
+        return true;
+    }
+    $.$mol_owning_check = $mol_owning_check;
+    function $mol_owning_catch(owner, having) {
+        if (!$mol_owning_allow(having))
+            return false;
+        if ($.$mol_owning_map.get(having))
+            return false;
+        $.$mol_owning_map.set(having, owner);
+        return true;
+    }
+    $.$mol_owning_catch = $mol_owning_catch;
+})($ || ($ = {}));
+
+;
+"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";
+
+;
+"use strict";
+var $;
+(function ($) {
+    if (!Symbol.dispose)
+        Symbol.dispose = Symbol('Symbol.dispose');
+    class $mol_object2 {
+        static $ = $;
+        [Symbol.toStringTag];
+        [$mol_ambient_ref] = null;
+        get $() {
+            if (this[$mol_ambient_ref])
+                return this[$mol_ambient_ref];
+            const owner = $mol_owning_get(this);
+            return this[$mol_ambient_ref] = owner?.$ || this.constructor.$ || $mol_object2.$;
+        }
+        set $(next) {
+            if (this[$mol_ambient_ref])
+                $mol_fail_hidden(new Error('Context already defined'));
+            this[$mol_ambient_ref] = next;
+        }
+        static create(init) {
+            const obj = new this;
+            if (init)
+                init(obj);
+            return obj;
+        }
+        static [Symbol.toPrimitive]() {
+            return this.toString();
+        }
+        static toString() {
+            return this[Symbol.toStringTag] || this.$.$mol_func_name(this);
+        }
+        static toJSON() {
+            return this.toString();
+        }
+        static [$mol_key_handle]() {
+            return this.toString();
+        }
+        destructor() { }
+        static destructor() { }
+        [Symbol.dispose]() {
+            this.destructor();
+        }
+        //[ Symbol.toPrimitive ]( hint: string ) {
+        //	return hint === 'number' ? this.valueOf() : this.toString()
+        //}
+        toString() {
+            return this[Symbol.toStringTag] || this.constructor.name + '<>';
+        }
+    }
+    $.$mol_object2 = $mol_object2;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_wrapper extends $mol_object2 {
+        static wrap;
+        static run(task) {
+            return this.func(task)();
+        }
+        static func(func) {
+            return this.wrap(func);
+        }
+        static get class() {
+            return (Class) => {
+                const construct = (target, args) => new Class(...args);
+                const handler = {
+                    construct: this.func(construct)
+                };
+                handler[Symbol.toStringTag] = Class.name + '#';
+                return new Proxy(Class, handler);
+            };
+        }
+        static get method() {
+            return (obj, name, descr = Reflect.getOwnPropertyDescriptor(obj, name)) => {
+                descr.value = this.func(descr.value);
+                return descr;
+            };
+        }
+        static get field() {
+            return (obj, name, descr = Reflect.getOwnPropertyDescriptor(obj, name)) => {
+                descr.get = descr.set = this.func(descr.get);
+                return descr;
+            };
+        }
+    }
+    $.$mol_wrapper = $mol_wrapper;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_memo extends $mol_wrapper {
+        static wrap(task) {
+            const store = new WeakMap();
+            const fun = function (next) {
+                if (next === undefined && store.has(this ?? fun))
+                    return store.get(this ?? fun);
+                const val = task.call(this, next) ?? next;
+                store.set(this ?? fun, val);
+                return val;
+            };
+            Reflect.defineProperty(fun, 'name', { value: task.name + ' ' });
+            return fun;
+        }
+    }
+    $.$mol_memo = $mol_memo;
+})($ || ($ = {}));
+
 ;
 "use strict";
 var $;
@@ -226,7 +518,32 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_pattern(Pattern) {
+    class $mol_memo_key extends $mol_wrapper {
+        static wrap(task) {
+            const store = new WeakMap();
+            const fun = function (key, next) {
+                let store2 = store.get(this ?? fun);
+                if (!store2)
+                    store.set(this ?? fun, store2 = new Map);
+                const key_str = $mol_key(key);
+                if (next === undefined && store2.has(key_str))
+                    return store2.get(key_str);
+                const val = task.call(this, key, next) ?? next;
+                store2.set(key_str, val);
+                return val;
+            };
+            Reflect.defineProperty(fun, 'name', { value: task.name + ' ' });
+            return fun;
+        }
+    }
+    $.$mol_memo_key = $mol_memo_key;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_schema_pattern = $mol_memo_key.func(function $mol_schema_pattern(Pattern) {
         return class $mol_schema_pattern_ extends $mol_schema_string {
             static Pattern = Pattern;
             static toString() {
@@ -244,42 +561,32 @@ var $;
             }
             static default = '';
         };
-    }
-    $.$mol_schema_pattern = $mol_schema_pattern;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    class $mol_schema_float extends $mol_schema_any {
-        static guard(value) {
-            if (typeof value === 'number')
-                return value;
-            return $mol_fail(new TypeError('Wrong type', { cause: { value, schema: this } }));
-        }
-        static default = Number.NaN;
-    }
-    $.$mol_schema_float = $mol_schema_float;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    class $mol_schema_integer extends $mol_schema_float {
-        $mol_schema_integer = true;
-        static guard(value) {
-            const val = super.guard(value);
-            if (!Number.isFinite(val))
-                return $mol_fail(new TypeError('Non finite', { cause: { value, schema: this } }));
-            if (Math.trunc(val) !== val)
-                return $mol_fail(new TypeError('Non integer', { cause: { value, schema: this } }));
-            return val;
+    $.$mol_schema_instance = $mol_memo_key.func(function $mol_schema_instance(Class, ...args) {
+        class $mol_schema_instance_ extends $mol_schema_any {
+            static Class = Class;
+            static toString() {
+                if (this !== $mol_schema_instance_)
+                    return super.toString();
+                return '$mol_schema_instance<' + $$.$mol_func_name(Class) + '>';
+            }
+            static guard(value) {
+                if (value != null && Object(value) instanceof Class)
+                    return value;
+                return $mol_fail(new TypeError('Wrong class', { cause: { value, schema: this } }));
+            }
+            static default = new Class(...args);
         }
-        static default = 0;
-    }
-    $.$mol_schema_integer = $mol_schema_integer;
+        return ((Class[Symbol.hasInstance] === $mol_schema_any[Symbol.hasInstance])
+            ? Class
+            : $mol_schema_instance_);
+    });
 })($ || ($ = {}));
 
 ;
@@ -289,7 +596,7 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_every(Schemas) {
+    $.$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() {
@@ -310,50 +617,47 @@ var $;
             }
             static default = Schemas.find(Scheme => this.check(Scheme.default));
         };
-    }
-    $.$mol_schema_every = $mol_schema_every;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_range(Min, Max) {
+    $.$mol_schema_range = $mol_memo_key.func(function $mol_schema_range(Range) {
         return class $mol_schema_range_ extends $mol_schema_any {
-            static Min = Min;
-            static Max = Max;
+            static Range = Range;
             static toString() {
                 if (this !== $mol_schema_range_)
                     return super.toString();
-                return '$mol_schema_range<' + $mol_key(Min) + ',' + $mol_key(Max) + '>';
+                return '$mol_schema_range<' + $mol_key(Range) + '>';
             }
             static guard(value) {
                 if (typeof value !== 'number' && typeof value !== 'bigint')
                     return $mol_fail(new TypeError('Uncomparable type', { cause: { value, schema: this } }));
-                if (!(value <= Max))
+                if (!(value <= Range[1]))
                     return $mol_fail(new TypeError('Too large', { cause: { value, schema: this } }));
-                if (!(value >= Min))
+                if (!(value >= Range[0]))
                     return $mol_fail(new TypeError('Too small', { cause: { value, schema: this } }));
                 return value;
             }
             static cast(val) {
-                if (val > Max)
-                    return Max;
-                if (val >= Min)
+                if (val > Range[1])
+                    return Range[1];
+                if (val >= Range[0])
                     return val;
-                return Min;
+                return Range[0];
             }
-            static default = Min;
+            static default = Range[0];
         };
-    }
-    $.$mol_schema_range = $mol_schema_range;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    class $mol_schema_positive extends $mol_schema_range(0, Number.POSITIVE_INFINITY) {
+    class $mol_schema_positive extends $mol_schema_range([0, Number.POSITIVE_INFINITY]) {
     }
     $.$mol_schema_positive = $mol_schema_positive;
 })($ || ($ = {}));
@@ -374,7 +678,7 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_enum(Options) {
+    $.$mol_schema_enum = $mol_memo_key.func(function $mol_schema_enum(Options) {
         return class $mol_schema_enum_ extends $mol_schema_any {
             static Options = Options;
             static toString() {
@@ -394,15 +698,14 @@ var $;
             }
             static default = Options[0];
         };
-    }
-    $.$mol_schema_enum = $mol_schema_enum;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    class $mol_schema_negative extends $mol_schema_range(Number.NEGATIVE_INFINITY, 0) {
+    class $mol_schema_negative extends $mol_schema_range([Number.NEGATIVE_INFINITY, 0]) {
     }
     $.$mol_schema_negative = $mol_schema_negative;
 })($ || ($ = {}));
@@ -411,7 +714,7 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_some(Variants) {
+    $.$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() {
@@ -441,15 +744,14 @@ var $;
             }
             static default = Variants[0].default;
         };
-    }
-    $.$mol_schema_some = $mol_schema_some;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_maybe(Some) {
+    $.$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;
             static toString() {
@@ -458,15 +760,14 @@ var $;
                 return '$mol_schema_maybe<' + $mol_key(Some) + '>';
             }
         };
-    }
-    $.$mol_schema_maybe = $mol_schema_maybe;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_list(Item) {
+    $.$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() {
@@ -494,22 +795,20 @@ var $;
             }
             static default = [];
         };
-    }
-    $.$mol_schema_list = $mol_schema_list;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_dict(Key, Val) {
+    $.$mol_schema_dict = $mol_memo_key.func(function $mol_schema_dict(Pair) {
         return class $mol_schema_dict_ extends $mol_schema_any {
-            static Key = Key;
-            static Val = Val;
+            static Pair = Pair;
             static toString() {
                 if (this !== $mol_schema_dict_)
                     return super.toString();
-                return '$mol_schema_dict<' + $mol_key(Key) + ',' + $mol_key(Key) + '>';
+                return '$mol_schema_dict<' + $mol_key(Pair) + '>';
             }
             static guard(value) {
                 if (Object.getPrototypeOf(Object.getPrototypeOf(value))) {
@@ -517,13 +816,13 @@ var $;
                 }
                 for (const key in value) {
                     try {
-                        Key.guard(key);
+                        Pair[0].guard(key);
                     }
                     catch (error) {
                         return $mol_fail(new TypeError('Wrong key', { cause: { key, error, value, schema: this } }));
                     }
                     try {
-                        Val.guard(value[key]);
+                        Pair[1].guard(value[key]);
                     }
                     catch (error) {
                         return $mol_fail(new TypeError('Wrong val', { cause: { key, error, value, schema: this } }));
@@ -536,23 +835,22 @@ var $;
                     return this.default;
                 const res = {};
                 for (const key in value) {
-                    if (!Key.check(key))
+                    if (!Pair[0].check(key))
                         continue;
-                    res[key] = Val.cast(value[key]);
+                    res[key] = Pair[1].cast(value[key]);
                 }
                 return res;
             }
             static default = {};
         };
-    }
-    $.$mol_schema_dict = $mol_schema_dict;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_record(Fields) {
+    $.$mol_schema_record = $mol_memo_key.func(function $mol_schema_record(Fields) {
         return class $mol_schema_record_ extends $mol_schema_any {
             static Fields = Fields;
             static toString() {
@@ -584,8 +882,7 @@ var $;
             }
             static default = Object.fromEntries(Object.entries(Fields).map(([field, Field]) => [field, Field.default]));
         };
-    }
-    $.$mol_schema_record = $mol_schema_record;
+    });
 })($ || ($ = {}));
 
 ;