@tstdl/base 0.88.3 → 0.88.4

package/http/client/http-client.js

@@ -15,7 +15,7 @@ import { encodeUtf8 } from '../../utils/encoding.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../utils/stream/readable-stream-from-promise.js';
-import { isArray, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
+import { isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
 import { buildUrl } from '../../utils/url-builder.js';
 import { HttpHeaders } from '../http-headers.js';
 import { HttpError, HttpErrorReason } from '../http.error.js';
@@ -284,7 +284,7 @@ function mapParameters(request, baseUrl) {
     if (request.mapParametersToQuery) {
         for (const entry of parameterEntries) {
             const [parameter, value] = entry;
-            if (isUndefined(value) || (isObject(value) && !isArray(value))) {
+            if (isUndefined(value) || isObject(value)) {
                 continue;
             }
             for (const val of toArray(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.88.3",
+  "version": "0.88.4",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/utils/merge.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import { assertArray, assertLiteralObject, assertMap, assertSet, isArray, isLiteralObject, isMap, isSet, isUndefined } from './type-guards.js';
+import { assertArray, assertMap, assertObject, assertSet, isArray, isMap, isObject, isSet, isUndefined } from './type-guards.js';
 export function merge(a, b) {
     if (isUndefined(a)) {
         return b;
@@ -7,8 +7,8 @@ export function merge(a, b) {
     if (isUndefined(b)) {
         return a;
     }
-    if (isLiteralObject(a)) {
-        assertLiteralObject(b, 'Cannot merge object into non-object.');
+    if (isObject(a)) {
+        assertObject(b, 'Cannot merge object into non-object.');
         return { ...a, ...b };
     }
     else if (isArray(a)) {

package/utils/object/object.js

@@ -1,7 +1,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 { isDefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
+import { isArray, isDefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
 export function hasOwnProperty(obj, key) {
     return Object.hasOwn(obj, key);
 }
@@ -90,7 +90,7 @@ export function deepObjectEntries(object, keepInnerObjects = false, prefix) {
         : allEntries.map(([key, value]) => [`${prefix}${key}`, value]);
     const entries = [];
     for (const [key, value] of rawEntries) {
-        if (isObject(value)) {
+        if (isObject(value) || isArray(value)) {
             if (keepInnerObjects) {
                 entries.push([key, value]);
             }

package/utils/type-guards.d.ts

@@ -78,12 +78,6 @@ export declare const assertSymbol: AssertFunction<symbol>;
 export declare const assertNotSymbol: AssertNotFunction<symbol>;
 export declare const assertSymbolPass: AssertPassFunction<symbol>;
 export declare const assertNotSymbolPass: AssertNotPassFunction<symbol>;
-export declare const isLiteralObject: IsFunction<object>;
-export declare const isNotLiteralObject: IsNotFunction<object>;
-export declare const assertLiteralObject: AssertFunction<object>;
-export declare const assertNotLiteralObject: AssertNotFunction<object>;
-export declare const assertLiteralObjectPass: AssertPassFunction<object>;
-export declare const assertNotLiteralObjectPass: AssertNotPassFunction<object>;
 export declare const isObject: IsFunction<object>;
 export declare const isNotObject: IsNotFunction<object>;
 export declare const assertObject: AssertFunction<object>;

package/utils/type-guards.js

@@ -104,14 +104,7 @@ export const assertSymbol = symbolGuards.assertSymbol;
 export const assertNotSymbol = symbolGuards.assertNotSymbol;
 export const assertSymbolPass = symbolGuards.assertSymbolPass;
 export const assertNotSymbolPass = symbolGuards.assertNotSymbolPass;
-const literalObjectGuards = createGuards('literal object', (value) => (typeof value == 'object') && (value != null) && (Reflect.getPrototypeOf(value) == Object.prototype) && (Reflect.getPrototypeOf(value).constructor == Object));
-export const isLiteralObject = literalObjectGuards.isLiteralObject;
-export const isNotLiteralObject = literalObjectGuards.isNotLiteralObject;
-export const assertLiteralObject = literalObjectGuards.assertLiteralObject;
-export const assertNotLiteralObject = literalObjectGuards.assertNotLiteralObject;
-export const assertLiteralObjectPass = literalObjectGuards.assertLiteralObjectPass;
-export const assertNotLiteralObjectPass = literalObjectGuards.assertNotLiteralObjectPass;
-const objectGuards = createGuards('object', (value) => (typeof value == 'object') && (value != null));
+const objectGuards = createGuards('object', (value) => (typeof value == 'object') && (value != null) && (Reflect.getPrototypeOf(value) == Object.prototype) && (Reflect.getPrototypeOf(value).constructor == Object));
 export const isObject = objectGuards.isObject;
 export const isNotObject = objectGuards.isNotObject;
 export const assertObject = objectGuards.assertObject;