@amritk/generate-examples 0.5.0 → 0.5.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 amritk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/generators/generate-arbitrary.js

@@ -83,19 +83,24 @@ const integerExpr = (schema) => {
     const opts = [];
     // With both `minimum` and `exclusiveMinimum` present the effective lower bound
     // is the tighter (larger) of the two, so combine them rather than letting one
-    // shadow the other via else-if.
+    // shadow the other via else-if. `fc.integer` also requires integral bounds, but
+    // the schema keywords may be fractional (`minimum: 2.5`, `exclusiveMinimum: 5.5`),
+    // so round each toward the satisfiable side: the smallest integer that still
+    // meets the lower bound, and the largest that still meets the upper.
+    // `Math.floor(x) + 1` is the smallest integer strictly greater than `x` (so it
+    // also handles integral exclusives); `Math.ceil(x) - 1` is the largest strictly less.
     const mins = [];
     if (hasMinimum(schema))
-        mins.push(Number(schema.minimum));
+        mins.push(Math.ceil(Number(schema.minimum)));
     if (hasExclusiveMinimum(schema))
-        mins.push(Number(schema.exclusiveMinimum) + 1);
+        mins.push(Math.floor(Number(schema.exclusiveMinimum)) + 1);
     if (mins.length > 0)
         opts.push(`min: ${Math.max(...mins)}`);
     const maxs = [];
     if (hasMaximum(schema))
-        maxs.push(Number(schema.maximum));
+        maxs.push(Math.floor(Number(schema.maximum)));
     if (hasExclusiveMaximum(schema))
-        maxs.push(Number(schema.exclusiveMaximum) - 1);
+        maxs.push(Math.ceil(Number(schema.exclusiveMaximum)) - 1);
     if (maxs.length > 0)
         opts.push(`max: ${Math.min(...maxs)}`);
     const base = opts.length > 0 ? `fc.integer({ ${opts.join(', ')} })` : 'fc.integer()';
@@ -173,14 +178,24 @@ const numberExpr = (schema) => {
     if (hasMultipleOf(schema) && schema.multipleOf > 0)
         return numberMultipleOfExpr(schema);
     const opts = ['noNaN: true', 'noDefaultInfinity: true'];
-    if (hasMinimum(schema))
+    // With both an inclusive and an exclusive bound on the same side, honour the
+    // tighter one instead of letting `minimum`/`maximum` shadow the exclusive via
+    // else-if (which would emit values that violate the exclusive bound). The
+    // exclusive bound wins ties, since it additionally excludes the endpoint.
+    if (hasMinimum(schema) &&
+        (!hasExclusiveMinimum(schema) || Number(schema.minimum) > Number(schema.exclusiveMinimum))) {
         opts.push(`min: ${schema.minimum}`);
-    else if (hasExclusiveMinimum(schema))
+    }
+    else if (hasExclusiveMinimum(schema)) {
         opts.push(`min: ${schema.exclusiveMinimum}`, 'minExcluded: true');
-    if (hasMaximum(schema))
+    }
+    if (hasMaximum(schema) &&
+        (!hasExclusiveMaximum(schema) || Number(schema.maximum) < Number(schema.exclusiveMaximum))) {
         opts.push(`max: ${schema.maximum}`);
-    else if (hasExclusiveMaximum(schema))
+    }
+    else if (hasExclusiveMaximum(schema)) {
         opts.push(`max: ${schema.exclusiveMaximum}`, 'maxExcluded: true');
+    }
     return `fc.double({ ${opts.join(', ')} })`;
 };
 /** Builds a `fc.array(...)` / `fc.uniqueArray(...)` / `fc.tuple(...)` expression for an array schema. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-examples",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Generate fast-check arbitraries and example values from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -47,8 +47,8 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.13.0",
-    "@amritk/runtime-validators": "0.7.0"
+    "@amritk/helpers": "0.13.2",
+    "@amritk/runtime-validators": "0.7.2"
   },
   "devDependencies": {
     "ajv": "^8.17.1"