@wener/utils 1.1.51 → 1.1.54

package/lib/objects/set.test.js

@@ -0,0 +1,522 @@
+/* eslint no-proto:0 no-prototype-builtins:0 */ function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+import { describe, expect, it, test } from "vitest";
+import { set } from "./set.js";
+test("set basics", function () {
+    expect(set({}, "c", 3), "should not give return value").toBe(undefined);
+    {
+        var item = {
+            foo: 1
+        };
+        set(item, "bar", 123);
+        expect(item, "should mutate original object").toEqual({
+            foo: 1,
+            bar: 123
+        });
+    }
+});
+describe("set objects", function () {
+    var run = function run(isMerge) {
+        var _$set = function (a, b, c) {
+            orig(a, b, c, isMerge);
+        };
+        var verb = isMerge ? "merge" : "overwrite";
+        it("should ".concat(verb, " existing object value :: simple"), function () {
+            var input = prepare({
+                hello: {
+                    a: 1
+                }
+            }).input;
+            _$set(input, "hello", {
+                foo: 123
+            });
+            if (isMerge) {
+                expect(input).toStrictEqual({
+                    hello: {
+                        a: 1,
+                        foo: 123
+                    }
+                });
+            }
+            else {
+                expect(input).toStrictEqual({
+                    hello: {
+                        foo: 123
+                    }
+                });
+            }
+        });
+        it("should ".concat(verb, " existing object value :: nested"), function () {
+            var _prepare = prepare({
+                a: {
+                    b: {
+                        c: 123
+                    }
+                }
+            }), input = _prepare.input, copy = _prepare.copy;
+            _$set(input, "a.b", {
+                foo: 123
+            });
+            if (isMerge) {
+                Object.assign(copy.a.b, {
+                    foo: 123
+                });
+            }
+            else {
+                copy.a.b = {
+                    foo: 123
+                };
+            }
+            expect(input).toStrictEqual(copy);
+        });
+        it("should ".concat(verb, " existing array value :: simple"), function () {
+            var input = prepare([
+                {
+                    foo: 1
+                }
+            ]).input;
+            _$set(input, "0", {
+                bar: 2
+            });
+            if (isMerge) {
+                expect(input).toEqual([
+                    {
+                        foo: 1,
+                        bar: 2
+                    }
+                ]);
+            }
+            else {
+                expect(input).toEqual([
+                    {
+                        bar: 2
+                    }
+                ]);
+            }
+        });
+        it("should ".concat(verb, " existing array value :: nested"), function () {
+            var input = prepare([
+                {
+                    name: "bob",
+                    age: 56,
+                    friends: [
+                        "foobar"
+                    ]
+                },
+                {
+                    name: "alice",
+                    age: 47,
+                    friends: [
+                        "mary"
+                    ]
+                }
+            ]).input;
+            _$set(input, "0", {
+                age: 57,
+                friends: [
+                    "alice",
+                    "mary"
+                ]
+            });
+            _$set(input, "1", {
+                friends: [
+                    "bob"
+                ]
+            });
+            _$set(input, "2", {
+                name: "mary",
+                age: 49,
+                friends: [
+                    "bob"
+                ]
+            });
+            if (isMerge) {
+                expect(input).toEqual([
+                    {
+                        name: "bob",
+                        age: 57,
+                        friends: [
+                            "alice",
+                            "mary"
+                        ]
+                    },
+                    {
+                        name: "alice",
+                        age: 47,
+                        friends: [
+                            "bob"
+                        ]
+                    },
+                    {
+                        name: "mary",
+                        age: 49,
+                        friends: [
+                            "bob"
+                        ]
+                    }
+                ]);
+            }
+            else {
+                expect(input).toEqual([
+                    {
+                        age: 57,
+                        friends: [
+                            "alice",
+                            "mary"
+                        ]
+                    },
+                    {
+                        friends: [
+                            "bob"
+                        ]
+                    },
+                    {
+                        name: "mary",
+                        age: 49,
+                        friends: [
+                            "bob"
+                        ]
+                    }
+                ]);
+            }
+        });
+    };
+    var prepare = function (x) {
+        return {
+            input: x,
+            copy: JSON.parse(JSON.stringify(x))
+        };
+    };
+    var orig = set;
+    run(true);
+    run(false);
+});
+describe("set arrays", function () {
+    it("should create array instead of object via numeric key :: simple", function () {
+        var input = {
+            a: 1
+        };
+        set(input, "e.0", 2);
+        expect(Array.isArray(input.e)).toBeTruthy();
+        expect(input.e[0]).toBe(2);
+        expect(input).toStrictEqual({
+            a: 1,
+            e: [
+                2
+            ]
+        });
+    });
+    it("should create array instead of object via numeric key :: nested", function () {
+        var input = {
+            a: 1
+        };
+        set(input, "e.0.0", 123);
+        expect(_instanceof(input.e, Array)).toBeTruthy();
+        expect(input.e[0][0]).toBe(123);
+        expect(input).toEqual({
+            a: 1,
+            e: [
+                [
+                    123
+                ]
+            ]
+        });
+    });
+    it("should be able to create object inside of array", function () {
+        var input = {};
+        set(input, [
+            "x",
+            "0",
+            "z"
+        ], 123);
+        expect(_instanceof(input.x, Array)).toBeTruthy();
+        expect(input).toEqual({
+            x: [
+                {
+                    z: 123
+                }
+            ]
+        });
+    });
+    it("should create arrays with hole(s) if needed", function () {
+        var input = {};
+        set(input, [
+            "x",
+            "1",
+            "z"
+        ], 123);
+        expect(_instanceof(input.x, Array)).toBeTruthy();
+        expect(input).toEqual({
+            x: [
+                undefined,
+                {
+                    z: 123
+                }
+            ]
+        });
+    });
+    it("should create object from decimal-like key :: array :: zero :: string", function () {
+        var input = {};
+        set(input, [
+            "x",
+            "10.0",
+            "z"
+        ], 123);
+        expect(_instanceof(input.x, Array)).toBeFalsy();
+        expect(input).toEqual({
+            x: {
+                "10.0": {
+                    z: 123
+                }
+            }
+        });
+    });
+    it("should create array from decimal-like key :: array :: zero :: number", function () {
+        var input = {};
+        set(input, [
+            "x",
+            10,
+            "z"
+        ], 123);
+        expect(_instanceof(input.x, Array)).toBeTruthy();
+        var x = Array(10);
+        x.push({
+            z: 123
+        });
+        expect(input).toEqual({
+            x: x
+        });
+    });
+    it("should create object from decimal-like key :: array :: nonzero", function () {
+        var input = {};
+        set(input, [
+            "x",
+            "10.2",
+            "z"
+        ], 123);
+        expect(_instanceof(input.x, Array)).toBeFalsy();
+        expect(input).toEqual({
+            x: {
+                "10.2": {
+                    z: 123
+                }
+            }
+        });
+    });
+});
+describe("set pollution", function () {
+    it("should protect against \"__proto__\" assignment", function () {
+        var input = {
+            abc: 123
+        };
+        var before = input.__proto__;
+        set(input, "__proto__.hello", 123);
+        expect(input.__proto__).toEqual(before);
+        expect(input).toEqual({
+            abc: 123
+        });
+    });
+    it("should protect against \"__proto__\" assignment :: nested", function () {
+        var input = {
+            abc: 123
+        };
+        var before = input.__proto__;
+        set(input, [
+            "xyz",
+            "__proto__",
+            "hello"
+        ], 123);
+        expect(input.__proto__).toEqual(before);
+        expect(input).toEqual({
+            abc: 123,
+            xyz: {}
+        });
+        expect(input.hello).toBe(undefined);
+    });
+    it("should ignore \"prototype\" assignment", function () {
+        var input = {
+            a: 123
+        };
+        set(input, "a.prototype.hello", "world");
+        expect(input.a.prototype).toBe(undefined);
+        expect(input.a.hello).toBe(undefined);
+        expect(input).toEqual({
+            a: {}
+        });
+        expect(JSON.stringify(input)).toBe("{\"a\":{}}");
+    });
+    it("should ignore \"constructor\" assignment :: direct", function () {
+        var Custom = function Custom() {
+            //
+        };
+        var input = {
+            a: 123
+        };
+        set(input, "a.constructor", Custom);
+        expect(input.a.constructor).not.toBe(Custom);
+        expect(_instanceof(input.a, Custom)).toBeFalsy();
+        expect(_instanceof(input.a.constructor, Object), "~> 123 -> {}").toBeTruthy();
+        expect(input.a.hasOwnProperty("constructor")).toBe(false);
+        expect(input).toEqual({
+            a: {}
+        });
+    });
+    it("should ignore \"constructor\" assignment :: nested", function () {
+        var input = {};
+        set(input, "constructor.prototype.hello", "world");
+        expect(input.hasOwnProperty("constructor")).toBe(false);
+        expect(input.hasOwnProperty("hello")).toBe(false);
+        expect(input).toEqual({});
+    });
+    // Test for CVE-2022-25645 - CWE-1321
+    it("should ignore JSON.parse crafted object with \"__proto__\" key", function () {
+        var a = {
+            b: {
+                c: 1
+            }
+        };
+        expect(a.polluted).toBe(undefined);
+        set(a, "b", JSON.parse("{\"__proto__\":{\"polluted\":\"Yes!\"}}"));
+        expect(a.polluted).toBe(undefined);
+    });
+});
+describe("set assigns", function () {
+    it("should add value to key path :: shallow :: string", function () {
+        var input = {};
+        set(input, "abc", 123);
+        expect(input).toEqual({
+            abc: 123
+        });
+    });
+    it("should add value to key path :: shallow :: array", function () {
+        var input = {};
+        set(input, [
+            "abc"
+        ], 123);
+        expect(input).toEqual({
+            abc: 123
+        });
+    });
+    it("should add value to key path :: nested :: string", function () {
+        var input = {};
+        set(input, "a.b.c", 123);
+        expect(input).toEqual({
+            a: {
+                b: {
+                    c: 123
+                }
+            }
+        });
+    });
+    it("should add value to key path :: nested :: array", function () {
+        var input = {};
+        set(input, [
+            "a",
+            "b",
+            "c"
+        ], 123);
+        expect(input).toEqual({
+            a: {
+                b: {
+                    c: 123
+                }
+            }
+        });
+    });
+    it("should create Array via integer key :: string", function () {
+        var input = {};
+        set(input, [
+            "foo",
+            "0"
+        ], 123);
+        expect(_instanceof(input.foo, Array)).toBeTruthy();
+        expect(input).toEqual({
+            foo: [
+                123
+            ]
+        });
+    });
+    it("should create Array via integer key :: number", function () {
+        var input = {};
+        set(input, [
+            "foo",
+            0
+        ], 123);
+        expect(_instanceof(input.foo, Array)).toBeTruthy();
+        expect(input).toEqual({
+            foo: [
+                123
+            ]
+        });
+    });
+});
+describe("set preserves", function () {
+    it("should preserve existing object structure", function () {
+        var input = {
+            a: {
+                b: {
+                    c: 123
+                }
+            }
+        };
+        set(input, "a.b.x.y", 456);
+        expect(input).toEqual({
+            a: {
+                b: {
+                    c: 123,
+                    x: {
+                        y: 456
+                    }
+                }
+            }
+        });
+    });
+    it("should overwrite existing non-object values as object", function () {
+        var input = {
+            a: {
+                b: 123
+            }
+        };
+        set(input, "a.b.c", "hello");
+        expect(input).toEqual({
+            a: {
+                b: {
+                    c: "hello"
+                }
+            }
+        });
+    });
+    it("should preserve existing object tree w/ array value", function () {
+        var input = {
+            a: {
+                b: {
+                    c: 123,
+                    d: {
+                        e: 5
+                    }
+                }
+            }
+        };
+        set(input, "a.b.d.z", [
+            1,
+            2,
+            3,
+            4
+        ]);
+        expect(input.a.b.d).toEqual({
+            e: 5,
+            z: [
+                1,
+                2,
+                3,
+                4
+            ]
+        });
+    });
+});

package/lib/schema/typebox/index.js

@@ -1,3 +1,2 @@
-export * as TypeBox from './typebox.js';
-
-//# sourceMappingURL=index.js.map
+import * as _TypeBox from "./typebox.js";
+export { _TypeBox as TypeBox };

package/lib/schema/typebox/typebox.js

@@ -1,12 +1,14 @@
 import { Value } from '@sinclair/typebox/value';
 // works like zod parse
-export const Parse = (T, value)=>// run transform, get T
+export var Parse = function(T, value) {
+    return(// run transform, get T
     Value.Decode(T, // remove additional
     Value.Clean(T, // add missing
     Value.Default(T, // '1' -> 1
-    Value.Convert(T, value))));
-export const SafeParse = (T, value)=>{
-    let out = Value.Clean(T, Value.Default(T, Value.Convert(T, value)));
+    Value.Convert(T, value)))));
+};
+export var SafeParse = function(T, value) {
+    var out = Value.Clean(T, Value.Default(T, Value.Convert(T, value)));
     if (Value.Check(T, out)) {
         // decode 也会 check
         return {
@@ -19,5 +21,3 @@ export const SafeParse = (T, value)=>{
         success: false
     };
 };
-
-//# sourceMappingURL=typebox.js.map