@tstdl/base 0.93.61 → 0.93.64

package/utils/object/object.js

@@ -3,7 +3,7 @@ import { filterAsync } from '../async-iterable-helpers/filter.js';
 import { mapAsync } from '../async-iterable-helpers/map.js';
 import { toArrayAsync } from '../async-iterable-helpers/to-array.js';
 import { toSnakeCase } from '../string/index.js';
-import { isArray, isDefined, isNotNullOrUndefined, isNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
+import { isArray, isDefined, isNotNull, isNotNullOrUndefined, isNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
 export function hasOwnProperty(obj, key) {
     return Object.hasOwn(obj, key);
 }
@@ -84,7 +84,7 @@ export function getGetter(obj, property, bind) {
         throw new Error(`Property ${property} does not exist.`);
     }
     let objOrPrototype = obj;
-    while (!hasOwnProperty(objOrPrototype, property)) {
+    while (isNotNull(objOrPrototype) && !hasOwnProperty(objOrPrototype, property)) {
         objOrPrototype = Object.getPrototypeOf(objOrPrototype);
     }
     const descriptor = Object.getOwnPropertyDescriptor(objOrPrototype, property);
@@ -123,33 +123,42 @@ export function deepObjectEntries(object, keepInnerObjects = false, prefix) {
     }
     return entries;
 }
-export function fromDeepObjectEntries(entries) {
-    const obj = {};
-    for (const [path, value] of entries) {
-        const jsonPath = JsonPath.from(path);
-        let target = obj;
-        for (let i = 0; i < jsonPath.nodes.length - 1; i++) {
-            const key = jsonPath.nodes[i];
-            if (hasOwnProperty(target, key)) {
-                target = target[key];
-            }
-            else {
-                const child = {};
-                target[key] = child;
-                target = child;
-            }
+export function assignDeep(target, path, value) {
+    const jsonPath = JsonPath.from(path);
+    let currentTarget = target;
+    for (let i = 0; i < jsonPath.nodes.length - 1; i++) {
+        const key = jsonPath.nodes[i];
+        if (key == '__proto__') {
+            throw new Error('Assignment to __proto__ is not allowed for security reasons.');
+        }
+        if (isDefined(currentTarget[key])) {
+            currentTarget = currentTarget[key];
+        }
+        else {
+            const child = {};
+            currentTarget[key] = child;
+            currentTarget = child;
         }
-        target[jsonPath.nodes.at(-1)] = value;
     }
+    currentTarget[jsonPath.nodes.at(-1)] = value;
+}
+export function assignDeepObjectEntries(target, entries) {
+    for (const [path, value] of entries) {
+        assignDeep(target, path, value);
+    }
+}
+export function fromDeepObjectEntries(entries) {
+    const obj = {};
+    assignDeepObjectEntries(obj, entries);
     return obj;
 }
-export function omit(object, ...keys) {
+export function omit(object, keys) {
     return filterObject(object, (_, key) => !keys.includes(key));
 }
-export function pick(object, ...keys) {
+export function pick(object, keys) {
     const result = {};
     for (const key of keys) {
-        if (hasOwnProperty(object, key)) {
+        if (key in object) {
             result[key] = object[key];
         }
     }

package/utils/stream/from-promise.js

@@ -2,8 +2,8 @@ import { resolveValueOrProvider } from '../value-or-provider.js';
 export function readableStreamFromPromise(promiseOrProvider) {
     const stream = new TransformStream();
     resolveValueOrProvider(promiseOrProvider)
-        .then(async (readable) => readable.pipeTo(stream.writable))
-        .catch(async (error) => stream.writable.abort(error).catch(() => { }));
+        .then(async (readable) => await readable.pipeTo(stream.writable))
+        .catch(async (error) => await stream.writable.abort(error).catch(() => { }));
     return stream.readable;
 }
 export function transformStreamFromPromise(promiseOrProvider) {