ts-data-forge 5.1.1 → 6.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/dist/guard/is-record.d.mts.map +1 -1
  2. package/dist/guard/is-record.mjs +1 -1
  3. package/dist/guard/is-record.mjs.map +1 -1
  4. package/package.json +1 -1
  5. package/src/guard/is-record.mts +1 -2
  6. package/src/guard/is-record.test.mts +57 -67
package/dist/guard/is-record.d.mts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,aACF,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,eAAe,EAAE,CAC5B,CAAC,EAAE,OAAO,KACP,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAY,CAAC"}
1
+ {"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,aAAmC,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,eAAe,EAAE,CAC5B,CAAC,EAAE,OAAO,KACP,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAY,CAAC"}
package/dist/guard/is-record.mjs CHANGED
@@ -38,7 +38,7 @@ import { isNonNullObject } from './is-non-null-object.mjs';
38
38
  * @see {@link isNonNullObject} - For checking any object type (includes arrays)
39
39
  * @see {@link hasKey} - For checking if a record has specific keys
40
40
  */
41
- const isRecord = (u) => isNonNullObject(u) && !Array.isArray(u);
41
+ const isRecord = (u) => isNonNullObject(u);
42
42
  /**
43
43
  * Type guard that checks if a value is a mutable record (an object with mutable string keys).
44
44
  *
package/dist/guard/is-record.mjs.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;MACU,QAAQ,GAAG,CAAC,CAAU,KACjC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI,MAAM,eAAe,GAEe;;;;"}
1
+ {"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACI,MAAM,QAAQ,GAAG,CAAC,CAAU,KAAyB,eAAe,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI,MAAM,eAAe,GAEe;;;;"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "ts-data-forge",
3
- "version": "5.1.1",
3
+ "version": "6.0.0",
4
4
  "private": false,
5
5
  "keywords": [
6
6
  "typescript",
package/src/guard/is-record.mts CHANGED
@@ -38,8 +38,7 @@ import { isNonNullObject } from './is-non-null-object.mjs';
38
38
  * @see {@link isNonNullObject} - For checking any object type (includes arrays)
39
39
  * @see {@link hasKey} - For checking if a record has specific keys
40
40
  */
41
- export const isRecord = (u: unknown): u is UnknownRecord =>
42
- isNonNullObject(u) && !Array.isArray(u);
41
+ export const isRecord = (u: unknown): u is UnknownRecord => isNonNullObject(u);
43
42
 
44
43
  /**
45
44
  * Type guard that checks if a value is a mutable record (an object with mutable string keys).
package/src/guard/is-record.test.mts CHANGED
@@ -2,110 +2,100 @@ import { expectType } from '../expect-type.mjs';
2
2
  import { isRecord } from './is-record.mjs';
3
3
 
4
4
  describe(isRecord, () => {
5
- test('{ x: 1 } is a record', () => {
6
- const obj = { x: 1 } as const;
5
+ describe('arrays are Records', () => {
6
+ test('number[] is assignable to Record<number, unknown>', () => {
7
+ const arr: Record<number, unknown> = [1, 2, 3];
7
8
 
8
- const unk: unknown = obj;
9
+ const unk: unknown = arr;
9
10
 
10
- const res = isRecord(unk);
11
+ assert.isTrue(isRecord(unk));
11
12
 
12
- expectType<typeof obj, UnknownRecord>('<=');
13
+ expectType<typeof unk, UnknownRecord>('<=');
14
+ });
13
15
 
14
- expectType<typeof res, boolean>('=');
16
+ test('string[] is assignable to Record<number, unknown>', () => {
17
+ const arr: Record<number, unknown> = ['1', '2', '3'];
15
18
 
16
- if (res) {
17
- expectType<typeof unk, UnknownRecord>('=');
18
- }
19
+ const unk: unknown = arr;
19
20
 
20
- assert.isTrue(res);
21
- });
22
-
23
- test('{} is a record', () => {
24
- const obj = {} as const;
25
-
26
- const unk: unknown = obj;
21
+ assert.isTrue(isRecord(unk));
27
22
 
28
- const res = isRecord(unk);
23
+ expectType<typeof unk, UnknownRecord>('<=');
24
+ });
29
25
 
30
- expectType<typeof obj, {}>('=');
26
+ test('[] is a record', () => {
27
+ const arr: unknown = [] as const;
31
28
 
32
- expectType<typeof res, boolean>('=');
29
+ const unk: unknown = arr;
33
30
 
34
- if (res) {
35
- expectType<typeof unk, UnknownRecord>('=');
36
- }
31
+ assert.isTrue(isRecord(unk));
37
32
 
38
- assert.isTrue(res);
33
+ expectType<typeof unk, UnknownRecord>('<=');
34
+ });
39
35
  });
40
36
 
41
- test('[] is not a record', () => {
42
- const obj: DeepReadonly<never[]> = [] as const;
43
-
44
- const unk: unknown = obj;
45
-
46
- const res = isRecord(unk);
47
-
48
- expectType<typeof obj, readonly never[]>('=');
37
+ describe('non-null objects are Records', () => {
38
+ test('{ x: 1 } is a record', () => {
39
+ const obj = { x: 1 } as const;
49
40
 
50
- expectType<typeof res, boolean>('=');
41
+ const unk: unknown = obj;
51
42
 
52
- assert.isFalse(res);
53
- });
54
-
55
- test('null is not a record', () => {
56
- const obj = null;
43
+ assert.isTrue(isRecord(unk));
57
44
 
58
- const unk: unknown = obj;
45
+ expectType<typeof unk, UnknownRecord>('<=');
46
+ });
59
47
 
60
- const res = isRecord(unk);
48
+ test('{} is a record', () => {
49
+ const obj = {} as const;
61
50
 
62
- expectType<typeof obj, null>('=');
51
+ const unk: unknown = obj;
63
52
 
64
- expectType<typeof res, boolean>('=');
53
+ assert.isTrue(isRecord(unk));
65
54
 
66
- assert.isFalse(res);
55
+ expectType<typeof unk, UnknownRecord>('<=');
56
+ });
67
57
  });
68
58
 
69
- test('undefined is not a record', () => {
70
- const obj = undefined;
71
-
72
- const unk: unknown = obj;
59
+ describe('primitives are not Records', () => {
60
+ test('null is not a record', () => {
61
+ const obj = null;
73
62
 
74
- const res = isRecord(unk);
63
+ const unk: unknown = obj;
75
64
 
76
- expectType<typeof obj, undefined>('=');
65
+ assert.isFalse(isRecord(unk));
77
66
 
78
- expectType<typeof res, boolean>('=');
67
+ expectType<typeof unk, UnknownRecord>('!<=');
68
+ });
79
69
 
80
- assert.isFalse(res);
81
- });
82
-
83
- test('3 is not a record', () => {
84
- const obj = 3;
70
+ test('undefined is not a record', () => {
71
+ const prm = undefined;
85
72
 
86
- const unk: unknown = obj;
73
+ const unk: unknown = prm;
87
74
 
88
- const res = isRecord(unk);
75
+ assert.isFalse(isRecord(unk));
89
76
 
90
- expectType<typeof obj, 3>('=');
77
+ expectType<typeof unk, UnknownRecord>('!<=');
78
+ });
91
79
 
92
- expectType<typeof res, boolean>('=');
80
+ test('3 is not a record', () => {
81
+ const prm = 3;
93
82
 
94
- assert.isFalse(res);
95
- });
83
+ const unk: unknown = prm;
96
84
 
97
- test('"str" is not a record', () => {
98
- const obj = 'str';
85
+ assert.isFalse(isRecord(unk));
99
86
 
100
- const unk: unknown = obj;
87
+ expectType<typeof unk, UnknownRecord>('!<=');
88
+ });
101
89
 
102
- const res = isRecord(unk);
90
+ test('"str" is not a record', () => {
91
+ const prm = 'str';
103
92
 
104
- expectType<typeof obj, 'str'>('=');
93
+ const unk: unknown = prm;
105
94
 
106
- expectType<typeof res, boolean>('=');
95
+ assert.isFalse(isRecord(unk));
107
96
 
108
- assert.isFalse(res);
97
+ expectType<typeof unk, UnknownRecord>('!<=');
98
+ });
109
99
  });
110
100
 
111
101
  // test('Map is not a record', () => {