ts-data-forge 14.10.1 → 14.11.0

package/src/number/operators/positive-finite-number.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `PositiveFiniteNumber` other than `isPositiveFiniteNumber`
+ * and `asPositiveFiniteNumber`, which
+ * `../branded-types/positive-finite-number.mts` reads. Generated by
+ * `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+  PositiveFiniteNumber,
+  number,
+  number
+>({
+  MIN_VALUE: Number.MIN_VALUE,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage: 'a positive finite number',
+} as const);

package/src/number/operators/positive-int.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `PositiveInt` other than `isPositiveInt` and
+ * `asPositiveInt`, which `../branded-types/positive-int.mts` reads. Generated
+ * by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveInt } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  PositiveInt,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'Integer',
+  MIN_VALUE: 1,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage: 'a positive integer',
+} as const);

package/src/number/operators/positive-int16.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `PositiveInt16` other than `isPositiveInt16` and
+ * `asPositiveInt16`, which `../branded-types/positive-int16.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveInt16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  PositiveInt16,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 1,
+  MAX_VALUE: 2 ** 15 - 1,
+  typeNameInMessage: 'a positive integer in [1, 2^15)',
+} as const);

package/src/number/operators/positive-int32.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `PositiveInt32` other than `isPositiveInt32` and
+ * `asPositiveInt32`, which `../branded-types/positive-int32.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveInt32 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  PositiveInt32,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 1,
+  MAX_VALUE: 2 ** 31 - 1,
+  typeNameInMessage: 'a positive integer in [1, 2^31)',
+} as const);

package/src/number/operators/positive-safe-int.mts

@@ -0,0 +1,34 @@
+/**
+ * The operators of `PositiveSafeInt` other than `isPositiveSafeInt` and
+ * `asPositiveSafeInt`, which `../branded-types/positive-safe-int.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveSafeInt, SafeUint } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  PositiveSafeInt,
+  1,
+  SafeUint
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 1,
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
+  MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
+  typeNameInMessage: 'a positive safe integer',
+} as const);

package/src/number/operators/positive-uint16.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `PositiveUint16` other than `isPositiveUint16` and
+ * `asPositiveUint16`, which `../branded-types/positive-uint16.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveUint16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  PositiveUint16,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 1,
+  MAX_VALUE: 2 ** 16 - 1,
+  typeNameInMessage: 'a positive integer in [1, 2^16)',
+} as const);

package/src/number/operators/positive-uint32.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `PositiveUint32` other than `isPositiveUint32` and
+ * `asPositiveUint32`, which `../branded-types/positive-uint32.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveUint32 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  PositiveUint32,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 1,
+  MAX_VALUE: 2 ** 32 - 1,
+  typeNameInMessage: 'a positive integer in [1, 2^32)',
+} as const);

package/src/number/operators/safe-int.mts

@@ -0,0 +1,35 @@
+/**
+ * The operators of `SafeInt` other than `isSafeInt` and `asSafeInt`, which
+ * `../branded-types/safe-int.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { SafeInt, SafeUint } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  abs,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  SafeInt,
+  SafeInt,
+  SafeUint
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-min-safe-integer
+  MIN_VALUE: Number.MIN_SAFE_INTEGER as SafeInt,
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
+  MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
+  typeNameInMessage: 'a safe integer',
+} as const);

package/src/number/operators/safe-uint.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `SafeUint` other than `isSafeUint` and `asSafeUint`, which
+ * `../branded-types/safe-uint.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { SafeUint } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  SafeUint,
+  0,
+  SafeUint
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 0,
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
+  MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
+  typeNameInMessage: 'a non-negative safe integer',
+} as const);

package/src/number/operators/uint.mts

@@ -0,0 +1,31 @@
+/**
+ * The operators of `Uint` other than `isUint` and `asUint`, which
+ * `../branded-types/uint.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { Uint } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  Uint,
+  0,
+  number
+>({
+  integerOrSafeInteger: 'Integer',
+  MIN_VALUE: 0,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage: 'a non-negative integer',
+} as const);

package/src/number/operators/uint16.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `Uint16` other than `isUint16` and `asUint16`, which
+ * `../branded-types/uint16.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { Uint16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  Uint16,
+  0,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 0,
+  MAX_VALUE: 2 ** 16 - 1,
+  typeNameInMessage: 'a non-negative integer less than 2^16',
+} as const);

package/src/number/operators/uint32.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `Uint32` other than `isUint32` and `asUint32`, which
+ * `../branded-types/uint32.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { Uint32 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  Uint32,
+  0,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 0,
+  MAX_VALUE: 2 ** 32 - 1,
+  typeNameInMessage: 'a non-negative integer less than 2^32',
+} as const);

package/src/number/operators/uint8.mts

@@ -0,0 +1,16 @@
+/**
+ * The operators of `Uint8` other than `isUint8` and `asUint8`, which
+ * `../enum/uint8.mts` reads. Generated by `gen:branded-number`; `renderModule`
+ * in `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { Uint16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { MAX_VALUE, MIN_VALUE, castType, fromNumber, is, random } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<Uint16, 0, 255>({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 0,
+    MAX_VALUE: 255,
+    typeNameInMessage: 'an non-negative integer less than 256',
+  } as const);

package/src/number/refined-number-utils.mts

@@ -17,7 +17,7 @@ import type {
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
-import { Num } from './num.mjs';
+import * as Num from './num/impl/index.mjs';
 
 /** @internal */
 export namespace TsDataForgeInternals {
@@ -106,6 +106,9 @@ export namespace TsDataForgeInternals {
 
     type CastToInt<N> = N extends Int ? N : never;
 
+    /** The closed binary arithmetic operations a branded namespace may expose. */
+    export type NumberClassBinOp = 'add' | 'div' | 'mul' | 'sub';
+
     /**
      * Generates a type-safe API for a branded number type based on its
      * characteristics.
@@ -122,9 +125,6 @@ export namespace TsDataForgeInternals {
      *   'positive' | 'range'
      * @internal
      */
-    /** The closed binary arithmetic operations a branded namespace may expose. */
-    export type NumberClassBinOp = 'add' | 'div' | 'mul' | 'sub';
-
     export type NumberClass<
       N extends UnknownNumberBrand,
       classes extends 'int' | 'non-negative' | 'positive' | 'range',

package/src/object/object.mts

@@ -16,7 +16,7 @@ import type {
   TypeEq,
   UnknownRecord,
 } from 'ts-type-forge';
-import { Arr } from '../array/index.mjs';
+import * as Arr from '../array/impl/index.mjs';
 import { Optional } from '../functional/index.mjs';
 import { hasKey, isRecord } from '../guard/index.mjs';
 
@@ -91,6 +91,10 @@ export namespace Obj {
    * **Type Safety**: Only keys that exist in the source record type are
    * allowed, preventing runtime errors from accessing non-existent properties.
    *
+   * **Key handling**: a numeric key `1` matches the property `'1'`, and
+   * symbol-keyed properties are picked like string-keyed ones. Only own
+   * enumerable properties are read.
+   *
    * @example
    *
    * ```ts
@@ -150,12 +154,12 @@ export namespace Obj {
       case 2: {
         const [record, keys] = args;
 
-        const keysSet = new Set<keyof R>(keys);
+        const keysSet = toOwnKeySet(keys);
 
         return (
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
           Object.fromEntries(
-            Object.entries(record).filter(([k, _v]) => keysSet.has(k)),
+            ownEnumerableEntries(record).filter(([k]) => keysSet.has(k)),
           ) as never
         );
       }
@@ -177,6 +181,10 @@ export namespace Obj {
    * allowed, and the return type precisely reflects which properties remain
    * after omission.
    *
+   * **Key handling**: a numeric key `1` matches the property `'1'`, and
+   * symbol-keyed properties are kept unless omitted, like string-keyed ones.
+   * Only own enumerable properties are copied.
+   *
    * @example
    *
    * ```ts
@@ -238,12 +246,12 @@ export namespace Obj {
       case 2: {
         const [record, keys] = args;
 
-        const keysSet = new Set<keyof R>(keys);
+        const keysSet = toOwnKeySet(keys);
 
         return (
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
           Object.fromEntries(
-            Object.entries(record).filter(([k, _v]) => !keysSet.has(k)),
+            ownEnumerableEntries(record).filter(([k]) => !keysSet.has(k)),
           ) as never
         );
       }
@@ -996,3 +1004,23 @@ declare namespace TsDataForgeInternals {
         ? MergeAll<Rest, MergeTwo<Acc, First>>
         : Acc;
 }
+
+/**
+ * The keys as `Reflect.ownKeys` reports them: a numeric key `1` becomes `'1'`,
+ * a symbol stays a symbol.
+ */
+const toOwnKeySet = (
+  keys: readonly PropertyKey[],
+): ReadonlySet<string | symbol> =>
+  new Set(keys.map((k) => (typeof k === 'number' ? k.toString() : k)));
+
+/**
+ * The own enumerable entries of `record`, string and symbol keys alike, in
+ * `Reflect.ownKeys` order. `Object.entries` would leave out the symbols.
+ */
+const ownEnumerableEntries = (
+  record: UnknownRecord,
+): readonly (readonly [string | symbol, unknown])[] =>
+  Reflect.ownKeys(record)
+    .filter((k) => Object.prototype.propertyIsEnumerable.call(record, k))
+    .map((k) => [k, Reflect.get(record, k)] as const);

package/src/object/object.test.mts

@@ -89,6 +89,32 @@ describe('pick', () => {
 
     assert.deepStrictEqual(result, { name: 'Alice' });
   });
+
+  test('pick matches a numeric key', () => {
+    const record = { 1: 'a', b: 2 } as const;
+
+    const result = Obj.pick(record, [1]);
+
+    expectType<typeof result, Readonly<{ 1: 'a' }>>('=');
+
+    assert.deepStrictEqual(result, { 1: 'a' });
+
+    assert.deepStrictEqual(Obj.pick([1])(record), { 1: 'a' });
+  });
+
+  test('pick matches a symbol key', () => {
+    const sym = Symbol('s');
+
+    const record = { [sym]: 'a', b: 2 } as const;
+
+    const result = Obj.pick(record, [sym]);
+
+    assert.deepStrictEqual(result, { [sym]: 'a' });
+
+    assert.deepStrictEqual(Obj.pick([sym])(record), { [sym]: 'a' });
+
+    assert.deepStrictEqual(Obj.pick(record, ['b']), { b: 2 });
+  });
 });
 
 describe('omit', () => {
@@ -132,6 +158,35 @@ describe('omit', () => {
     assert.deepStrictEqual(result, original);
   });
 
+  test('omit matches a numeric key', () => {
+    const record = { 1: 'a', b: 2 } as const;
+
+    const result = Obj.omit(record, [1]);
+
+    expectType<typeof result, Readonly<{ b: 2 }>>('=');
+
+    assert.deepStrictEqual(result, { b: 2 });
+
+    assert.deepStrictEqual(Obj.omit([1])(record), { b: 2 });
+  });
+
+  test('omit keeps the symbol keys it is not asked to omit', () => {
+    const sym = Symbol('s');
+
+    const other = Symbol('other');
+
+    const record = { [sym]: 'a', [other]: 'o', b: 2 } as const;
+
+    assert.deepStrictEqual(Obj.omit(record, [sym]), { [other]: 'o', b: 2 });
+
+    assert.deepStrictEqual(Obj.omit([sym])(record), { [other]: 'o', b: 2 });
+
+    assert.deepStrictEqual(Obj.omit(record, ['b']), {
+      [sym]: 'a',
+      [other]: 'o',
+    });
+  });
+
   test('should omit multiple keys in curried form', () => {
     const omitBAndD = Obj.omit(['b', 'd']);
 

package/src/others/fast-deep-equal.mts

@@ -1,4 +1,4 @@
-import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';
+import { isMap, isRegExp, isSet, isTypedArray } from '../built-in-tag.mjs';
 import { hasKey, isRecord } from '../guard/index.mjs';
 
 /**

package/src/others/replace-equal-deep.mts

@@ -1,4 +1,4 @@
-import type { MutableRecord, UnknownRecord } from 'ts-type-forge';
+import type { UnknownRecord } from 'ts-type-forge';
 import { hasKey, isRecord } from '../guard/index.mjs';
 import { fastDeepEqual } from './fast-deep-equal.mjs';
 
@@ -202,7 +202,10 @@ const replaceObject = (
 
   let mut_isNext = true;
 
-  const mut_shared: MutableRecord<string, unknown> = {};
+  // Entries rather than `copy[k] = result`: assigning an own `__proto__` key
+  // (which `JSON.parse` produces) would call the setter and replace the copy's
+  // prototype, while `Object.fromEntries` defines it as a property.
+  const mut_sharedEntries: (readonly [string, unknown])[] = [];
 
   for (const k of nextKeys) {
     const value = next[k];
@@ -215,10 +218,14 @@ const replaceObject = (
 
     mut_isNext &&= Object.is(result, value);
 
-    mut_shared[k] = result;
+    mut_sharedEntries.push([k, result]);
   }
 
-  return mut_isCurrent ? current : mut_isNext ? next : mut_shared;
+  return mut_isCurrent
+    ? current
+    : mut_isNext
+      ? next
+      : Object.fromEntries(mut_sharedEntries);
 };
 
 // What an item of `next` is matched with when nothing of `current` is.

package/src/others/replace-equal-deep.test.mts

@@ -117,6 +117,32 @@ describe(replaceEqualDeep, () => {
     assert.isFalse(Object.hasOwn(shared, 'a'));
   });
 
+  test('copies an own __proto__ key as a property, not as the prototype', () => {
+    const current: unknown = JSON.parse('{"__proto__":{"x":1},"a":[1]}');
+
+    const next: unknown = JSON.parse('{"__proto__":{"x":1},"a":[2]}');
+
+    const result = replaceEqualDeep(current, next);
+
+    assert.isTrue(isRecord(result));
+
+    assert.strictEqual(Object.getPrototypeOf(result), Object.prototype);
+
+    assert.deepStrictEqual(Object.keys(result), ['__proto__', 'a']);
+
+    assert.strictEqual(JSON.stringify(result), '{"__proto__":{"x":1},"a":[2]}');
+
+    assert.notProperty(result, 'x');
+
+    // The unchanged `__proto__` value is reused from `current`.
+    assert.isTrue(isRecord(current));
+
+    assert.strictEqual(
+      Object.getOwnPropertyDescriptor(result, '__proto__')?.value,
+      Object.getOwnPropertyDescriptor(current, '__proto__')?.value,
+    );
+  });
+
   test('matches array items by index by default', () => {
     const one: Numbered = { number: 1 } as const;