lakutata 2.0.29 → 2.0.31

package/README.md

@@ -28,8 +28,8 @@ to freely encapsulate and call third-party modules using Lakutata's dependency i
 
 ## ✨ Getting started
 
-- 👉 To check out the **[guide](http://docs.lakutata.com)**, visit **[docs.lakutata.com](http://docs.lakutata.com)**. 
-- 👉 To see usage **[examples](http://examples.lakutata.com)**, visit **[examples.lakutata.com](http://examples.lakutata.com)**.
+- 👉 Check out the **[guide](https://github.com/lakutata/lakutata/blob/main/doc/en/Overview.md)**. 
+- 👉 查看 **[指南](https://github.com/lakutata/lakutata/blob/main/doc/zh/Overview.md)**。
 
 ## 🌎 License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lakutata",
-  "version": "2.0.29",
+  "version": "2.0.31",
   "description": "An IoC-based universal application framework.",
   "exports": {
     ".": {

package/src/lib/base/internal/ObjectInjection.cjs

@@ -4,9 +4,9 @@ Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-const e = require("../../../constants/DIMetadataKey.cjs");
+const t = require("../../../constants/DIMetadataKey.cjs");
 
-const t = require("../../helpers/ObjectConstructor.cjs");
+const e = require("../../helpers/ObjectConstructor.cjs");
 
 const r = require("../../helpers/ObjectParentConstructors.cjs");
 
@@ -19,37 +19,46 @@ require("../../helpers/As.cjs");
 require("../../helpers/ObjectParentConstructor.cjs");
 
 function c(c, a, n, o) {
-    let s;
-    if (Reflect.hasOwnMetadata(e.DI_TARGET_CONSTRUCTOR_INJECTS, t.ObjectConstructor(c))) {
-        s = Reflect.getOwnMetadata(e.DI_TARGET_CONSTRUCTOR_INJECTS, t.ObjectConstructor(c));
+    let T;
+    if (Reflect.hasOwnMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, e.ObjectConstructor(c))) {
+        T = Reflect.getOwnMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, e.ObjectConstructor(c));
     } else {
-        s = new Map;
+        T = new Map;
         const a = [];
-        r.ObjectParentConstructors(t.ObjectConstructor(c)).forEach((t => {
-            if (Reflect.hasOwnMetadata(e.DI_TARGET_CONSTRUCTOR_INJECTS, t)) a.unshift(Reflect.getOwnMetadata(e.DI_TARGET_CONSTRUCTOR_INJECTS, t));
+        r.ObjectParentConstructors(e.ObjectConstructor(c)).forEach((e => {
+            if (Reflect.hasOwnMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, e)) a.unshift(Reflect.getOwnMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, e));
         }));
-        a.forEach((e => e.forEach(((e, t) => s.set(t, e)))));
+        a.forEach((t => t.forEach(((t, e) => T.set(e, t)))));
     }
-    s.set(a, {
+    T.set(a, {
         name: n,
         transform: o
     });
-    Reflect.defineMetadata(e.DI_TARGET_CONSTRUCTOR_INJECTS, s, t.ObjectConstructor(c));
+    Reflect.defineMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, T, e.ObjectConstructor(c));
 }
 
-function a(r) {
-    const c = Reflect.getOwnMetadata(e.DI_TARGET_CONSTRUCTOR_INJECTS, t.ObjectConstructor(r));
-    if (c) return c;
+function a(c) {
+    const a = Reflect.getOwnMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, e.ObjectConstructor(c)) || new Map;
+    r.ObjectParentConstructors(e.ObjectConstructor(c)).forEach((e => {
+        if (Reflect.hasOwnMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, e)) {
+            const r = Reflect.getOwnMetadata(t.DI_TARGET_CONSTRUCTOR_INJECTS, e);
+            r.forEach(((t, e) => {
+                if (a.has(e)) return;
+                a.set(e, t);
+            }));
+        }
+    }));
+    if (a) return a;
     return new Map;
 }
 
-function n(t) {
-    if (!Reflect.hasOwnMetadata(e.DI_TARGET_CONSTRUCTOR_AUTOLOAD, t)) Reflect.defineMetadata(e.DI_TARGET_CONSTRUCTOR_AUTOLOAD, true, t);
-    return t;
+function n(e) {
+    if (!Reflect.hasOwnMetadata(t.DI_TARGET_CONSTRUCTOR_AUTOLOAD, e)) Reflect.defineMetadata(t.DI_TARGET_CONSTRUCTOR_AUTOLOAD, true, e);
+    return e;
 }
 
-function o(t) {
-    return !!Reflect.getOwnMetadata(e.DI_TARGET_CONSTRUCTOR_AUTOLOAD, t);
+function o(e) {
+    return !!Reflect.getOwnMetadata(t.DI_TARGET_CONSTRUCTOR_AUTOLOAD, e);
 }
 
 exports.GetObjectInjectItemsByPrototype = a;

package/src/lib/base/internal/ObjectInjection.mjs

@@ -12,7 +12,7 @@ import "../../helpers/As.mjs";
 
 import "../../helpers/ObjectParentConstructor.mjs";
 
-function n(e, n, o, s) {
+function n(e, n, f, o) {
     let c;
     if (Reflect.hasOwnMetadata(t, a(e))) {
         c = Reflect.getOwnMetadata(t, a(e));
@@ -25,19 +25,28 @@ function n(e, n, o, s) {
         n.forEach((t => t.forEach(((t, e) => c.set(e, t)))));
     }
     c.set(n, {
-        name: o,
-        transform: s
+        name: f,
+        transform: o
     });
     Reflect.defineMetadata(t, c, a(e));
 }
 
-function o(e) {
-    const r = Reflect.getOwnMetadata(t, a(e));
-    if (r) return r;
+function f(e) {
+    const n = Reflect.getOwnMetadata(t, a(e)) || new Map;
+    r(a(e)).forEach((e => {
+        if (Reflect.hasOwnMetadata(t, e)) {
+            const a = Reflect.getOwnMetadata(t, e);
+            a.forEach(((t, e) => {
+                if (n.has(e)) return;
+                n.set(e, t);
+            }));
+        }
+    }));
+    if (n) return n;
     return new Map;
 }
 
-function s(t) {
+function o(t) {
     if (!Reflect.hasOwnMetadata(e, t)) Reflect.defineMetadata(e, true, t);
     return t;
 }
@@ -46,4 +55,4 @@ function c(t) {
     return !!Reflect.getOwnMetadata(e, t);
 }
 
-export { o as GetObjectInjectItemsByPrototype, c as GetObjectIsAutoload, s as MarkObjectAsAutoload, n as SetObjectInjectItem };
+export { f as GetObjectInjectItemsByPrototype, c as GetObjectIsAutoload, o as MarkObjectAsAutoload, n as SetObjectInjectItem };

package/src/lib/core/Time.cjs

@@ -149,6 +149,9 @@ class Time extends Date {
     toISOString() {
         return this.#e.toISOString();
     }
+    toDate() {
+        return this.#e.toDate();
+    }
     isBefore(e, t) {
         return this.#e.isBefore(new Time(e).#e, t);
     }

package/src/lib/core/Time.mjs

@@ -143,6 +143,9 @@ class Time extends Date {
     toISOString() {
         return this.#e.toISOString();
     }
+    toDate() {
+        return this.#e.toDate();
+    }
     isBefore(e, t) {
         return this.#e.isBefore(new Time(e).#e, t);
     }

package/src/lib/validation/VLD.cjs

@@ -10649,7 +10649,7 @@ class ValidateMethods {
 
 const Kr = s.As(Xr.extend((e => ({
     type: "number",
-    base: e.number().integer(),
+    base: e.number(),
     messages: {
         "number.int8": "{{#label}} must be a valid Int8 value (between -128 and 127)",
         "number.uint8": "{{#label}} must be a valid UInt8 value (between 0 and 255)",
@@ -10663,7 +10663,21 @@ const Kr = s.As(Xr.extend((e => ({
     rules: {
         int8: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -128
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 127
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int8"
                 });
             },
@@ -10675,7 +10689,21 @@ const Kr = s.As(Xr.extend((e => ({
         },
         uint8: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 255
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint8"
                 });
             },
@@ -10687,7 +10715,21 @@ const Kr = s.As(Xr.extend((e => ({
         },
         int16: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -32768
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 32767
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int16"
                 });
             },
@@ -10699,7 +10741,21 @@ const Kr = s.As(Xr.extend((e => ({
         },
         uint16: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 65535
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint16"
                 });
             },
@@ -10711,7 +10767,21 @@ const Kr = s.As(Xr.extend((e => ({
         },
         int32: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -2147483648
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 2147483647
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int32"
                 });
             },
@@ -10723,7 +10793,21 @@ const Kr = s.As(Xr.extend((e => ({
         },
         uint32: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 4294967295
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint32"
                 });
             },
@@ -10735,7 +10819,21 @@ const Kr = s.As(Xr.extend((e => ({
         },
         int64: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -9007199254740991
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 9007199254740991
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int64"
                 });
             },
@@ -10749,7 +10847,21 @@ const Kr = s.As(Xr.extend((e => ({
         },
         uint64: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s.As({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s.As({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 9007199254740991
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint64"
                 });
             },

package/src/lib/validation/VLD.mjs

@@ -10635,7 +10635,7 @@ class ValidateMethods {
 
 const Fr = s(Ur.extend((e => ({
     type: "number",
-    base: e.number().integer(),
+    base: e.number(),
     messages: {
         "number.int8": "{{#label}} must be a valid Int8 value (between -128 and 127)",
         "number.uint8": "{{#label}} must be a valid UInt8 value (between 0 and 255)",
@@ -10649,7 +10649,21 @@ const Fr = s(Ur.extend((e => ({
     rules: {
         int8: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -128
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 127
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int8"
                 });
             },
@@ -10661,7 +10675,21 @@ const Fr = s(Ur.extend((e => ({
         },
         uint8: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 255
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint8"
                 });
             },
@@ -10673,7 +10701,21 @@ const Fr = s(Ur.extend((e => ({
         },
         int16: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -32768
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 32767
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int16"
                 });
             },
@@ -10685,7 +10727,21 @@ const Fr = s(Ur.extend((e => ({
         },
         uint16: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 65535
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint16"
                 });
             },
@@ -10697,7 +10753,21 @@ const Fr = s(Ur.extend((e => ({
         },
         int32: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -2147483648
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 2147483647
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int32"
                 });
             },
@@ -10709,7 +10779,21 @@ const Fr = s(Ur.extend((e => ({
         },
         uint32: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 4294967295
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint32"
                 });
             },
@@ -10721,7 +10805,21 @@ const Fr = s(Ur.extend((e => ({
         },
         int64: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: -9007199254740991
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 9007199254740991
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "int64"
                 });
             },
@@ -10735,7 +10833,21 @@ const Fr = s(Ur.extend((e => ({
         },
         uint64: {
             method() {
-                return this.$_addRule({
+                return this.$_addRule("integer").$_addRule(s({
+                    name: "min",
+                    method: "compare",
+                    args: {
+                        limit: 0
+                    },
+                    operator: ">="
+                })).$_addRule(s({
+                    name: "max",
+                    method: "compare",
+                    args: {
+                        limit: 9007199254740991
+                    },
+                    operator: "<="
+                })).$_addRule({
                     name: "uint64"
                 });
             },