json-schema-library 11.4.0 → 11.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.4.0",
+  "version": "11.4.1",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "types": "./dist/index.d.cts",
   "exports": {
@@ -18,6 +18,16 @@
     },
     "./package.json": "./package.json"
   },
+  "typesVersions": {
+    "*": {
+      "formats": [
+        "./dist/formats.d.cts"
+      ],
+      "remotes": [
+        "./dist/remotes.d.cts"
+      ]
+    }
+  },
   "scripts": {
     "coverage": "nyc npm run test --reporter=lcov",
     "dist": "tsdown -f esm -f cjs --minify --report --attw --unused; pnpm run dist:iife;",

package/src/keywords/type.test.ts

@@ -20,3 +20,16 @@ describe("keyword : type : validation", () => {
         });
     });
 });
+
+describe("keyword : type : reduce", () => {
+    it("should reduce array-type to the last matching data-type", () => {
+        const { node } = compileSchema({ type: ["null", "integer"] }).reduceNode(123);
+        assert.equal(node?.type, "integer");
+        assert.equal(node?.schema.type, "integer");
+    });
+    it("should reduce array-type to the first matching data-type", () => {
+        const { node } = compileSchema({ type: ["null", "integer"] }).reduceNode(null);
+        assert.equal(node?.type, "null");
+        assert.equal(node?.schema.type, "null");
+    });
+});

package/src/utils/mergeSchema.test.ts

@@ -78,4 +78,41 @@ describe("mergeSchema", () => {
         );
         assert.deepEqual(schema.items.anyOf, [{ type: "string" }, { type: "number" }]);
     });
+
+    describe("type", () => {
+        it("should return last type if they conflict", () => {
+            const schema = mergeSchema({ type: "array" }, { type: "integer" });
+            assert.deepEqual(schema.type, "integer");
+        });
+
+        it("should not merge mixed data types with string first", () => {
+            const schema = mergeSchema({ type: "array" }, { type: ["array", "object"] });
+            assert.deepEqual(schema.type, "array");
+        });
+
+        it("should not merge mixed data types with string second", () => {
+            const schema = mergeSchema({ type: ["array", "object"] }, { type: "array" });
+            assert.deepEqual(schema.type, "array");
+        });
+
+        it("should  merge mixed data types if they have no type in common", () => {
+            const schema = mergeSchema({ type: ["array", "object"] }, { type: "integer" });
+            assert.deepEqual(schema.type, ["array", "object", "integer"]);
+        });
+
+        it("should merge return last type if they do not match", () => {
+            const schema = mergeSchema({ type: "object" }, { type: "array" });
+            assert.deepEqual(schema.type, "array");
+        });
+
+        it("should merge array types", () => {
+            const schema = mergeSchema({ type: ["object"] }, { type: ["array"] });
+            assert.deepEqual(schema.type, ["object", "array"]);
+        });
+
+        it("should merge array types without duplicated", () => {
+            const schema = mergeSchema({ type: ["integer", "object"] }, { type: ["object", "array"] });
+            assert.deepEqual(schema.type, ["integer", "object", "array"]);
+        });
+    });
 });

package/src/utils/mergeSchema.ts

@@ -32,7 +32,10 @@ export function mergeSchema2(a: unknown, b: unknown, property?: string): unknown
         return newObject;
     }
 
-    if (Array.isArray(a) && Array.isArray(b)) {
+    const aIsArray = Array.isArray(a);
+    const bIsArray = Array.isArray(b);
+
+    if (aIsArray && bIsArray) {
         if (property === "required" || property === "anyOf") {
             return a.concat(b).filter((item, index, array) => array.indexOf(item) === index);
         }
@@ -66,11 +69,29 @@ export function mergeSchema2(a: unknown, b: unknown, property?: string): unknown
         return [...result, ...append].filter((item, index, array) => array.indexOf(item) === index);
     }
 
-    if (Array.isArray(b)) {
+    // mixed data-type for type keyword
+    if (property === "type" && (aIsArray || bIsArray)) {
+        // we merge to the specific type
+        if (aIsArray && a.includes(b)) {
+            return b;
+        }
+        if (bIsArray && b.includes(a)) {
+            return a;
+        }
+        // extend the types if they do not match
+        if (aIsArray) {
+            return [...a, b];
+        }
+        if (bIsArray) {
+            return [...b, a];
+        }
+    }
+
+    if (bIsArray) {
         return b;
     }
 
-    if (Array.isArray(a)) {
+    if (aIsArray) {
         return a;
     }