lib0 1.0.0-rc.35 → 1.0.0-rc.36

package/dist/number.d.ts

@@ -4,6 +4,7 @@ export const LOWEST_INT32: number;
 export const HIGHEST_INT32: 2147483647;
 export const HIGHEST_UINT32: 4294967295;
 export const isInteger: (number: unknown) => boolean;
+export const isSafeInteger: (number: unknown) => boolean;
 export const isNaN: (number: unknown) => boolean;
 export const parseInt: (string: string, radix?: number) => number;
 export function countBits(n: number): number;

package/dist/schema.d.ts

@@ -480,17 +480,26 @@ export const $$symbol: Schema<Schema<Symbol>>;
 export const $number: Schema<number>;
 export const $$number: Schema<Schema<number>>;
 /**
- * A number without fractional component (`Number.isInteger`). The unwrapped type is still
- * `number` - JS has no separate integer type.
+ * A number without fractional component in the safe integer range (`Number.isSafeInteger`,
+ * i.e. `|n| <= 2^53 - 1`). The unwrapped type is still `number` - JS has no separate integer type.
+ *
+ * The range restriction guarantees that every `$int` is exactly representable as a 64-bit
+ * signed integer (`BigInt(n)` is lossless, databases can store it in an `int64` / `BIGINT` column).
+ * Values like `1e20` are integers to `Number.isInteger`, but they are neither exact (every float
+ * beyond 2^53 rounds to a multiple of a power of two) nor storable in 64 bits, so they are
+ * rejected. Use `$number` for unbounded floats and `$bigint` for arbitrary-precision integers.
  *
  * @type {Schema<number>}
  */
 export const $int: Schema<number>;
 export const $$int: Schema<Schema<number>>;
 /**
- * An unsigned integer: a number without fractional component that is `>= 0`. The unwrapped type is
+ * An unsigned integer: a `$int` that is `>= 0` (so `0 <= n <= 2^53 - 1`). The unwrapped type is
  * still `number` - JS has no separate integer type.
  *
+ * Like `$int`, every `$uint` is exactly representable as a 64-bit integer (signed or unsigned).
+ * See `$int` for why the range is restricted.
+ *
  * @type {Schema<number>}
  */
 export const $uint: Schema<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.35",
+  "version": "1.0.0-rc.36",
   "description": "isomorphic utility functions",
   "sideEffects": false,
   "type": "module",

package/src/number.js

@@ -14,6 +14,7 @@ export const HIGHEST_INT32 = binary.BITS31
 export const HIGHEST_UINT32 = binary.BITS32
 
 export const isInteger = Number.isInteger
+export const isSafeInteger = Number.isSafeInteger
 export const isNaN = Number.isNaN
 export const parseInt = Number.parseInt
 

package/src/schema.js

@@ -670,7 +670,12 @@ export class $Record extends Schema {
    * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
    */
   check (o, err) {
-    return o != null && object.every(o, (vv, vk) => {
+    if (o === null || !object.isObject(o)) {
+      /* c8 ignore next */
+      err?.extend(null, 'Record', o === null ? 'null' : typeof o)
+      return false
+    }
+    return object.every(o, (vv, vk) => {
       const ck = this.shape.keys.check(vk, err)
       /* c8 ignore next */
       !ck && err?.extend(vk + '', 'Record', typeof o, ck ? 'Key doesn\'t match schema' : 'Value doesn\'t match value')
@@ -1028,21 +1033,30 @@ export const $number = /* @__PURE__ */$custom(o => typeof o === 'number')
 export const $$number = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$type('s:$number', $number))
 
 /**
- * A number without fractional component (`Number.isInteger`). The unwrapped type is still
- * `number` - JS has no separate integer type.
+ * A number without fractional component in the safe integer range (`Number.isSafeInteger`,
+ * i.e. `|n| <= 2^53 - 1`). The unwrapped type is still `number` - JS has no separate integer type.
+ *
+ * The range restriction guarantees that every `$int` is exactly representable as a 64-bit
+ * signed integer (`BigInt(n)` is lossless, databases can store it in an `int64` / `BIGINT` column).
+ * Values like `1e20` are integers to `Number.isInteger`, but they are neither exact (every float
+ * beyond 2^53 rounds to a multiple of a power of two) nor storable in 64 bits, so they are
+ * rejected. Use `$number` for unbounded floats and `$bigint` for arbitrary-precision integers.
  *
  * @type {Schema<number>}
  */
-export const $int = /* @__PURE__ */$custom(o => number.isInteger(o))
+export const $int = /* @__PURE__ */$custom(o => number.isSafeInteger(o))
 export const $$int = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$type('s:$int', $int))
 
 /**
- * An unsigned integer: a number without fractional component that is `>= 0`. The unwrapped type is
+ * An unsigned integer: a `$int` that is `>= 0` (so `0 <= n <= 2^53 - 1`). The unwrapped type is
  * still `number` - JS has no separate integer type.
  *
+ * Like `$int`, every `$uint` is exactly representable as a 64-bit integer (signed or unsigned).
+ * See `$int` for why the range is restricted.
+ *
  * @type {Schema<number>}
  */
-export const $uint = /* @__PURE__ */$custom(o => number.isInteger(o) && o >= 0)
+export const $uint = /* @__PURE__ */$custom(o => number.isSafeInteger(o) && o >= 0)
 export const $$uint = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$type('s:$uint', $uint))
 
 /**
@@ -1425,11 +1439,11 @@ const _createCoercer = ($s, cache) => {
   if (_isMeta($$int, $s) || _isMeta($$uint, $s)) {
     const min = _isMeta($$uint, $s) ? 0 : -Infinity
     return (o, path, ctx) => {
-      if (number.isInteger(o) && o >= min) return o
+      if (number.isSafeInteger(o) && o >= min) return o
       const t = typeof o
       if (t === 'boolean' || t === 'bigint' || (t === 'string' && o.trim() !== '')) {
         const n = Number(o)
-        if (number.isInteger(n) && n >= min) return n
+        if (number.isSafeInteger(n) && n >= min) return n
       }
       return _fail(ctx, path, o, expected)
     }