@stacksjs/arrays 0.64.6 → 0.65.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.
- package/dist/arr.d.ts +3 -0
- package/dist/contains.d.ts +70 -0
- package/dist/helpers.d.ts +174 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +2 -2
- package/dist/index.js.map +7 -7
- package/dist/macro.d.ts +31 -0
- package/dist/math.d.ts +171 -0
- package/package.json +8 -13
- package/src/arr.ts +1 -1
- package/src/contains.ts +9 -9
- package/src/helpers.ts +21 -14
- package/src/macro.ts +12 -16
- package/src/math.ts +17 -6
package/dist/arr.d.ts
ADDED
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Returns true if the needle is contained in the haystack.
|
|
3
|
+
*
|
|
4
|
+
* @param needle
|
|
5
|
+
* @param haystack
|
|
6
|
+
* @example
|
|
7
|
+
* ```ts
|
|
8
|
+
* contains('foo', ['foo', 'bar']) // true
|
|
9
|
+
* contains('foo', ['bar']) // false
|
|
10
|
+
* ```
|
|
11
|
+
*/
|
|
12
|
+
export declare function contains(needle: string, haystack: string[]): boolean;
|
|
13
|
+
/**
|
|
14
|
+
* Returns true if all needles are contained in the haystack.
|
|
15
|
+
* @param needles
|
|
16
|
+
* @param haystack
|
|
17
|
+
* @example
|
|
18
|
+
* ```ts
|
|
19
|
+
* containsAll(['foo', 'bar'], ['foo', 'bar', 'baz']) // true
|
|
20
|
+
* containsAll(['foo', 'bar'], ['foo', 'baz']) // false
|
|
21
|
+
* ```
|
|
22
|
+
*/
|
|
23
|
+
export declare function containsAll(needles: string[], haystack: string[]): boolean;
|
|
24
|
+
/**
|
|
25
|
+
* Returns true if any needle is contained in the haystack.
|
|
26
|
+
* @param needles
|
|
27
|
+
* @param haystack
|
|
28
|
+
* @example
|
|
29
|
+
* ```ts
|
|
30
|
+
* containsAny(['foo', 'bar'], ['foo', 'bar', 'baz']) // true
|
|
31
|
+
* containsAny(['foo', 'bar'], ['foo', 'baz']) // true
|
|
32
|
+
* containsAny(['foo', 'bar'], ['baz']) // false
|
|
33
|
+
* ```
|
|
34
|
+
*/
|
|
35
|
+
export declare function containsAny(needles: string[], haystack: string[]): boolean;
|
|
36
|
+
/**
|
|
37
|
+
* Returns true if none of the needles are contained in the haystack.
|
|
38
|
+
* @param needles
|
|
39
|
+
* @param haystack
|
|
40
|
+
* @example
|
|
41
|
+
* ```ts
|
|
42
|
+
* containsNone(['foo', 'bar'], ['foo', 'bar', 'baz']) // false
|
|
43
|
+
* containsNone(['foo', 'bar'], ['foo', 'baz']) // false
|
|
44
|
+
* containsNone(['foo', 'bar'], ['baz']) // true
|
|
45
|
+
* ```
|
|
46
|
+
*/
|
|
47
|
+
export declare function containsNone(needles: string[], haystack: string[]): boolean;
|
|
48
|
+
/**
|
|
49
|
+
* Returns true if all needles are contained in the haystack.
|
|
50
|
+
* @param needles
|
|
51
|
+
* @param haystack
|
|
52
|
+
* @example
|
|
53
|
+
* ```ts
|
|
54
|
+
* containsOnly(['foo', 'bar'], ['foo', 'bar', 'baz']) // false
|
|
55
|
+
* containsOnly(['foo', 'bar'], ['foo', 'baz']) // false
|
|
56
|
+
* containsOnly(['foo', 'bar'], ['foo', 'bar']) // true
|
|
57
|
+
* ```
|
|
58
|
+
*/
|
|
59
|
+
export declare function containsOnly(needles: string[], haystack: string[]): boolean;
|
|
60
|
+
/**
|
|
61
|
+
* Returns true if the needle is not contained in the haystack.
|
|
62
|
+
* @param needle
|
|
63
|
+
* @param haystack
|
|
64
|
+
* @example
|
|
65
|
+
* ```ts
|
|
66
|
+
* doesNotContain('foo', ['foo', 'bar']) // false
|
|
67
|
+
* doesNotContain('foo', ['bar']) // true
|
|
68
|
+
* ```
|
|
69
|
+
*/
|
|
70
|
+
export declare function doesNotContain(needle: string, haystack: string[]): boolean;
|
|
@@ -0,0 +1,174 @@
|
|
|
1
|
+
import type { Arrayable, Nullable } from "@stacksjs/types";
|
|
2
|
+
/**
|
|
3
|
+
* Convert `Arrayable<T>` to `Array<T>`
|
|
4
|
+
*
|
|
5
|
+
* @category Array
|
|
6
|
+
* @example
|
|
7
|
+
* ```ts
|
|
8
|
+
* toArray('foo') // ['foo']
|
|
9
|
+
* toArray(['foo']) // ['foo']
|
|
10
|
+
* toArray(null) // []
|
|
11
|
+
* toArray(undefined) // []
|
|
12
|
+
* toArray(1) // [1]
|
|
13
|
+
* toArray([1]) // [1]
|
|
14
|
+
* toArray({ foo: 'bar' }) // [{ foo: 'bar' }]
|
|
15
|
+
* toArray([{ foo: 'bar' }]) // [{ foo: 'bar' }]
|
|
16
|
+
* ```
|
|
17
|
+
*/
|
|
18
|
+
export declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
|
|
19
|
+
/**
|
|
20
|
+
* Flatten `Arrayable<T>` to `Array<T>`
|
|
21
|
+
*
|
|
22
|
+
* @category Array
|
|
23
|
+
* @example
|
|
24
|
+
* ```ts
|
|
25
|
+
* flatten([1, [2, [3, [4, [5]]]]]) // [1, 2, 3, 4, 5]
|
|
26
|
+
* ```
|
|
27
|
+
*/
|
|
28
|
+
export declare function flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[];
|
|
29
|
+
/**
|
|
30
|
+
* Use rest arguments to merge arrays
|
|
31
|
+
*
|
|
32
|
+
* @category Array
|
|
33
|
+
* @example
|
|
34
|
+
* ```ts
|
|
35
|
+
* mergeArrayable([1, 2], [3, 4], [5, 6]) // [1, 2, 3, 4, 5, 6]
|
|
36
|
+
* ```
|
|
37
|
+
*/
|
|
38
|
+
export declare function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
|
|
39
|
+
export type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any;
|
|
40
|
+
/**
|
|
41
|
+
* Divide an array into two parts by a filter function
|
|
42
|
+
*
|
|
43
|
+
* @category Array
|
|
44
|
+
* @example
|
|
45
|
+
* ```ts
|
|
46
|
+
* const [odd, even] = partition([1, 2, 3, 4], i => i % 2 != 0)
|
|
47
|
+
* console.log(odd) // [1, 3]
|
|
48
|
+
* console.log(even) // [2, 4]
|
|
49
|
+
* ```
|
|
50
|
+
*/
|
|
51
|
+
export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]];
|
|
52
|
+
export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]];
|
|
53
|
+
export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>): [T[], T[], T[], T[]];
|
|
54
|
+
export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>): [T[], T[], T[], T[], T[]];
|
|
55
|
+
export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[]];
|
|
56
|
+
export declare function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>, f3: PartitionFilter<T>, f4: PartitionFilter<T>, f5: PartitionFilter<T>, f6: PartitionFilter<T>): [T[], T[], T[], T[], T[], T[], T[]];
|
|
57
|
+
/**
|
|
58
|
+
* Unique an Array
|
|
59
|
+
*
|
|
60
|
+
* @category Array
|
|
61
|
+
* @example
|
|
62
|
+
* ```ts
|
|
63
|
+
* uniq([1, 2, 3, 3, 2, 1]) // [1, 2, 3]
|
|
64
|
+
* ```
|
|
65
|
+
*/
|
|
66
|
+
export declare function uniq<T>(array: readonly T[]): T[];
|
|
67
|
+
/**
|
|
68
|
+
* Unique an Array
|
|
69
|
+
*
|
|
70
|
+
* @param array
|
|
71
|
+
* @example
|
|
72
|
+
* ```ts
|
|
73
|
+
* unique([1, 2, 3, 3, 2, 1]) // [1, 2, 3]
|
|
74
|
+
* ```
|
|
75
|
+
*/
|
|
76
|
+
export declare function unique<T>(array: readonly T[]): T[];
|
|
77
|
+
/**
|
|
78
|
+
* Unique an Array by a custom equality function
|
|
79
|
+
*
|
|
80
|
+
* @category Array
|
|
81
|
+
* @example
|
|
82
|
+
* ```ts
|
|
83
|
+
* uniqueBy([1, 2, 3, 3, 2, 1], (a, b) => a === b) // [1, 2, 3]
|
|
84
|
+
* ```
|
|
85
|
+
*/
|
|
86
|
+
export declare function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
|
|
87
|
+
/**
|
|
88
|
+
* Get last item
|
|
89
|
+
*
|
|
90
|
+
* @category Array
|
|
91
|
+
* @example
|
|
92
|
+
* ```ts
|
|
93
|
+
* last([1, 2, 3]) // 3
|
|
94
|
+
* ```
|
|
95
|
+
*/
|
|
96
|
+
export declare function last(array: readonly []): undefined;
|
|
97
|
+
export declare function last<T>(array: readonly T[]): T;
|
|
98
|
+
/**
|
|
99
|
+
* Remove an item from Array
|
|
100
|
+
*
|
|
101
|
+
* @category Array
|
|
102
|
+
* @example
|
|
103
|
+
* ```ts
|
|
104
|
+
* const arr = [1, 2, 3]
|
|
105
|
+
* remove(arr, 2) // true
|
|
106
|
+
* Arr.remove(arr, 4) // false
|
|
107
|
+
* console.log(arr) // [1, 3]
|
|
108
|
+
*/
|
|
109
|
+
export declare function remove<T>(array: T[], value: T): boolean;
|
|
110
|
+
/**
|
|
111
|
+
* Get nth item of Array. Negative for backward
|
|
112
|
+
*
|
|
113
|
+
* @category Array
|
|
114
|
+
* @example
|
|
115
|
+
* ```ts
|
|
116
|
+
* at([1, 2, 3], 1) // 2
|
|
117
|
+
* at([1, 2, 3], -1) // 3
|
|
118
|
+
* at([1, 2, 3], 3) // undefined
|
|
119
|
+
* at([1, 2, 3], -4) // undefined
|
|
120
|
+
* ```
|
|
121
|
+
*/
|
|
122
|
+
export declare function at(array: readonly [], index: number): undefined;
|
|
123
|
+
export declare function at<T>(array: readonly T[], index: number): T;
|
|
124
|
+
/**
|
|
125
|
+
* Move an item from one index to another
|
|
126
|
+
* @param array
|
|
127
|
+
* @param from
|
|
128
|
+
* @param to
|
|
129
|
+
*
|
|
130
|
+
* @category Array
|
|
131
|
+
* @example
|
|
132
|
+
* ```ts
|
|
133
|
+
* move([1, 2, 3, 4], 0, 2) // [2, 3, 1, 4]
|
|
134
|
+
* move([1, 2, 3, 4], 0, -1) // [2, 3, 4, 1]
|
|
135
|
+
* move([1, 2, 3, 4], -1, 0) // [4, 1, 2, 3]
|
|
136
|
+
* move([1, 2, 3, 4], -1, -2) // [1, 4, 2, 3]
|
|
137
|
+
* move([1, 2, 3, 4], 1, 1) // [1, 2, 3, 4]
|
|
138
|
+
* ```
|
|
139
|
+
*/
|
|
140
|
+
export declare function move<T>(array: T[], from: number, to: number): T[];
|
|
141
|
+
/**
|
|
142
|
+
* Clamp a number to the index range of an array.
|
|
143
|
+
*
|
|
144
|
+
* @category Array
|
|
145
|
+
* @example
|
|
146
|
+
* ```ts
|
|
147
|
+
* clampArrayRange([1, 2, 3], 0) // 0
|
|
148
|
+
* clampArrayRange([1, 2, 3], 1) // 1
|
|
149
|
+
* clampArrayRange([1, 2, 3], 2) // 2
|
|
150
|
+
* clampArrayRange([1, 2, 3], 3) // 2
|
|
151
|
+
* clampArrayRange([1, 2, 3], 4) // 2
|
|
152
|
+
* clampArrayRange([1, 2, 3], -1) // 0
|
|
153
|
+
*/
|
|
154
|
+
export declare function clampArrayRange(arr: readonly unknown[], n: number): number;
|
|
155
|
+
/**
|
|
156
|
+
* Get random items from an array
|
|
157
|
+
*
|
|
158
|
+
* @category Array
|
|
159
|
+
* @example
|
|
160
|
+
* ```ts
|
|
161
|
+
* sample([1, 2, 3, 4], 2) // [2, 3]
|
|
162
|
+
* ```
|
|
163
|
+
*/
|
|
164
|
+
export declare function sample<T>(arr: T[], count: number): T[];
|
|
165
|
+
/**
|
|
166
|
+
* Shuffle an array. This function mutates the array.
|
|
167
|
+
*
|
|
168
|
+
* @category Array
|
|
169
|
+
* @example
|
|
170
|
+
* ```ts
|
|
171
|
+
* shuffle([1, 2, 3, 4]) // [2, 4, 1, 3]
|
|
172
|
+
* ```
|
|
173
|
+
*/
|
|
174
|
+
export declare function shuffle<T>(array: T[]): T[];
|
package/dist/index.d.ts
ADDED
package/dist/index.js
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
// @bun
|
|
2
|
-
var
|
|
2
|
+
var v=Object.defineProperty;var h=(z,E)=>{for(var G in E)v(z,G,{get:E[G],enumerable:!0,configurable:!0,set:(H)=>E[G]=()=>H})};var f={};h(f,{zScore:()=>i,variance:()=>x,uniqueBy:()=>C,unique:()=>u,uniq:()=>Y,toArray:()=>P,sum:()=>$,standardDeviation:()=>g,shuffle:()=>w,sample:()=>_,remove:()=>F,range:()=>b,product:()=>d,percentile:()=>c,partition:()=>j,move:()=>N,mode:()=>q,min:()=>p,mergeArrayable:()=>T,median:()=>Q,max:()=>A,last:()=>V,interquartileRange:()=>l,flatten:()=>X,doesNotContain:()=>S,covariance:()=>s,containsOnly:()=>O,containsNone:()=>D,containsAny:()=>W,containsAll:()=>U,contains:()=>M,clampArrayRange:()=>R,avg:()=>o,average:()=>J,at:()=>Z});function M(z,E){return E.some((G)=>z.includes(G))}function U(z,E){return z.every((G)=>M(G,E))}function W(z,E){return z.some((G)=>M(G,E))}function D(z,E){return!W(z,E)}function O(z,E){return U(E,z)}function S(z,E){return!M(z,E)}import{clamp as m}from"@stacksjs/utils";function P(z){return z=z??[],Array.isArray(z)?z:[z]}function X(z){return P(z).reduce((E,G)=>E.concat(Array.isArray(G)?X(G):G),[])}function T(...z){return z.flatMap((E)=>P(E))}function j(z,...E){const G=Array.from({length:E.length+1}).fill(null).map(()=>[]);return z.forEach((H,I,K)=>{let L=0;for(let B of E){if(B(H,I,K)){G[L].push(H);return}L+=1}G[L].push(H)}),G}function Y(z){return Array.from(new Set(z))}function u(z){return Y(z)}function C(z,E){return z.reduce((G,H)=>{if(G.findIndex((K)=>E(H,K))===-1)G.push(H);return G},[])}function V(z){return Z(z,-1)}function F(z,E){if(!z)return!1;const G=z.indexOf(E);if(G>=0)return z.splice(G,1),!0;return!1}function Z(z,E){const G=z.length;if(!G)return;if(E<0)E+=G;return z[E]}function N(z,E,G){const H=z.length;if(!H)return[];if(E<0)E+=H;if(G<0)G+=H;const I=z.splice(E,1)[0];return z.splice(G,0,I),z}function R(z,E){return m(E,0,z.length-1)}function _(z,E){return Array.from({length:E},()=>z[Math.floor(Math.random()*z.length)])}function w(z){for(let E=z.length-1;E>0;E--){const G=Math.floor(Math.random()*(E+1));[z[E],z[G]]=[z[G],z[E]]}return z}function J(z){return $(z)/z.length}function o(z){return J(z)}function Q(z){if(z.length===0)throw new Error("Cannot compute median of an empty array");const E=[...z].sort((I,K)=>I-K),G=Math.floor(E.length/2);let H;if(E.length%2!==0)H=E[G];else H=(E[G]+E[G-1])/2;return H}function q(z){return z.sort((E,G)=>z.filter((H)=>H===E).length-z.filter((H)=>H===G).length).pop()}function $(z){return z.reduce((E,G)=>E+G,0)}function d(z){return z.reduce((E,G)=>E*G,1)}function p(z){return Math.min(...z)}function A(z){return Math.max(...z)}function b(z){return A(z)-p(z)}function x(z){const E=J(z);return J(z.map((G)=>(G-E)**2))}function g(z){return Math.sqrt(x(z))}function i(z,E){return(E-J(z))/g(z)}function c(z,E){const G=[...z].sort((B,k)=>B-k),H=E/100*(G.length-1),I=Math.floor(H),K=Math.ceil(H),L=H-I;if(K===I)return G[H]??0;return(1-L)*(G[I]??0)+L*(G[K]??0)}function l(z){const E=Q(z.slice(0,Math.floor(z.length/2)));return Q(z.slice(Math.ceil(z.length/2)))-E}function s(z,E){if(z.length!==E.length)throw new Error("Arrays must have the same length");const G=J(z),H=J(E);return J(z.map((I,K)=>(I-G)*(E[K]-H)))}var Jz={contains(z,E){return M(z,E)},containsAll(z,E){return U(z,E)},containsAny(z,E){return W(z,E)},containsNone(z,E){return D(z,E)},containsOnly(z,E){return O(z,E)},doesNotContain(z,E){return S(z,E)},toArray(z){return P(z)},flatten(z){return X(z)},mergeArrayable(...z){return T(...z)},partition(z,E){return j(z,E)},random(z,E=1){return _(z,E).filter((G)=>G!=null)},sample(z,E=1){return _(z,E)},unique(z){return Y(z)},uniqueBy(z,E){return C(z,E)},last(z){return V(z)},remove(z,E){return F(z,E)},at(z,E){return Z(z,E)},range(z){return b(z)},move(z,E,G){return N(z,E,G)},clampArrayRange(z,E){return R(z,E)},shuffle(z){return w(z)},sum(z){return $(z)},average(z){return J(z)},avg(z){return J(z)},median(z){return Q(z)},mode(z){return q(z)}};export{i as zScore,x as variance,C as uniqueBy,u as unique,Y as uniq,P as toArray,$ as sum,g as standardDeviation,w as shuffle,_ as sample,F as remove,b as range,d as product,c as percentile,j as partition,N as move,q as mode,p as min,T as mergeArrayable,Q as median,A as max,V as last,l as interquartileRange,X as flatten,S as doesNotContain,s as covariance,O as containsOnly,D as containsNone,W as containsAny,U as containsAll,M as contains,R as clampArrayRange,o as avg,J as average,Z as at,f as arr,Jz as Arr};
|
|
3
3
|
|
|
4
|
-
//# debugId=
|
|
4
|
+
//# debugId=B6B872CC06F3654D64756E2164756E21
|
|
5
5
|
//# sourceMappingURL=index.js.map
|
package/dist/index.js.map
CHANGED
|
@@ -1,13 +1,13 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 3,
|
|
3
|
-
"sources": ["../src/
|
|
3
|
+
"sources": ["../src/contains.ts", "../src/helpers.ts", "../src/math.ts", "../src/macro.ts"],
|
|
4
4
|
"sourcesContent": [
|
|
5
|
-
"
|
|
6
|
-
"
|
|
7
|
-
"/**\n * Returns
|
|
8
|
-
"import type { Arrayable, Nullable } from '@stacksjs/types'\nimport { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'\nimport
|
|
5
|
+
"/**\n * Returns true if the needle is contained in the haystack.\n *\n * @param needle\n * @param haystack\n * @example\n * ```ts\n * contains('foo', ['foo', 'bar']) // true\n * contains('foo', ['bar']) // false\n * ```\n */\nexport function contains(needle: string, haystack: string[]): boolean {\n return haystack.some(hay => needle.includes(hay))\n}\n\n/**\n * Returns true if all needles are contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsAll(['foo', 'bar'], ['foo', 'bar', 'baz']) // true\n * containsAll(['foo', 'bar'], ['foo', 'baz']) // false\n * ```\n */\nexport function containsAll(needles: string[], haystack: string[]): boolean {\n return needles.every(needle => contains(needle, haystack))\n}\n\n/**\n * Returns true if any needle is contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsAny(['foo', 'bar'], ['foo', 'bar', 'baz']) // true\n * containsAny(['foo', 'bar'], ['foo', 'baz']) // true\n * containsAny(['foo', 'bar'], ['baz']) // false\n * ```\n */\nexport function containsAny(needles: string[], haystack: string[]): boolean {\n return needles.some(needle => contains(needle, haystack))\n}\n\n/**\n * Returns true if none of the needles are contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsNone(['foo', 'bar'], ['foo', 'bar', 'baz']) // false\n * containsNone(['foo', 'bar'], ['foo', 'baz']) // false\n * containsNone(['foo', 'bar'], ['baz']) // true\n * ```\n */\nexport function containsNone(needles: string[], haystack: string[]): boolean {\n return !containsAny(needles, haystack)\n}\n\n/**\n * Returns true if all needles are contained in the haystack.\n * @param needles\n * @param haystack\n * @example\n * ```ts\n * containsOnly(['foo', 'bar'], ['foo', 'bar', 'baz']) // false\n * containsOnly(['foo', 'bar'], ['foo', 'baz']) // false\n * containsOnly(['foo', 'bar'], ['foo', 'bar']) // true\n * ```\n */\nexport function containsOnly(needles: string[], haystack: string[]): boolean {\n return containsAll(haystack, needles)\n}\n\n/**\n * Returns true if the needle is not contained in the haystack.\n * @param needle\n * @param haystack\n * @example\n * ```ts\n * doesNotContain('foo', ['foo', 'bar']) // false\n * doesNotContain('foo', ['bar']) // true\n * ```\n */\nexport function doesNotContain(needle: string, haystack: string[]): boolean {\n return !contains(needle, haystack)\n}\n",
|
|
6
|
+
"import type { Arrayable, Nullable } from '@stacksjs/types'\nimport { clamp } from '@stacksjs/utils'\n\n/**\n * Convert `Arrayable<T>` to `Array<T>`\n *\n * @category Array\n * @example\n * ```ts\n * toArray('foo') // ['foo']\n * toArray(['foo']) // ['foo']\n * toArray(null) // []\n * toArray(undefined) // []\n * toArray(1) // [1]\n * toArray([1]) // [1]\n * toArray({ foo: 'bar' }) // [{ foo: 'bar' }]\n * toArray([{ foo: 'bar' }]) // [{ foo: 'bar' }]\n * ```\n */\nexport function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {\n array = array ?? []\n return Array.isArray(array) ? array : [array]\n}\n\n/**\n * Flatten `Arrayable<T>` to `Array<T>`\n *\n * @category Array\n * @example\n * ```ts\n * flatten([1, [2, [3, [4, [5]]]]]) // [1, 2, 3, 4, 5]\n * ```\n */\nexport function flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[] {\n return toArray(array).reduce((acc: T[], val) => acc.concat(Array.isArray(val) ? flatten(val) : (val as T)), [])\n}\n\n/**\n * Use rest arguments to merge arrays\n *\n * @category Array\n * @example\n * ```ts\n * mergeArrayable([1, 2], [3, 4], [5, 6]) // [1, 2, 3, 4, 5, 6]\n * ```\n */\nexport function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T> {\n return args.flatMap(i => toArray(i))\n}\n\nexport type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any\n\n/**\n * Divide an array into two parts by a filter function\n *\n * @category Array\n * @example\n * ```ts\n * const [odd, even] = partition([1, 2, 3, 4], i => i % 2 != 0)\n * console.log(odd) // [1, 3]\n * console.log(even) // [2, 4]\n * ```\n */\nexport function partition<T>(array: readonly T[], f1: PartitionFilter<T>): [T[], T[]]\nexport function partition<T>(array: readonly T[], f1: PartitionFilter<T>, f2: PartitionFilter<T>): [T[], T[], T[]]\nexport function partition<T>(\n array: readonly T[],\n f1: PartitionFilter<T>,\n f2: PartitionFilter<T>,\n f3: PartitionFilter<T>,\n): [T[], T[], T[], T[]]\nexport function partition<T>(\n array: readonly T[],\n f1: PartitionFilter<T>,\n f2: PartitionFilter<T>,\n f3: PartitionFilter<T>,\n f4: PartitionFilter<T>,\n): [T[], T[], T[], T[], T[]]\nexport function partition<T>(\n array: readonly T[],\n f1: PartitionFilter<T>,\n f2: PartitionFilter<T>,\n f3: PartitionFilter<T>,\n f4: PartitionFilter<T>,\n f5: PartitionFilter<T>,\n): [T[], T[], T[], T[], T[], T[]]\nexport function partition<T>(\n array: readonly T[],\n f1: PartitionFilter<T>,\n f2: PartitionFilter<T>,\n f3: PartitionFilter<T>,\n f4: PartitionFilter<T>,\n f5: PartitionFilter<T>,\n f6: PartitionFilter<T>,\n): [T[], T[], T[], T[], T[], T[], T[]]\nexport function partition<T>(array: readonly T[], ...filters: PartitionFilter<T>[]): any {\n const result: T[][] = Array.from({ length: filters.length + 1 })\n .fill(null)\n .map(() => [])\n\n array.forEach((e, idx, arr) => {\n let i = 0\n for (const filter of filters) {\n if (filter(e, idx, arr)) {\n ;(result[i] as T[]).push(e)\n return\n }\n i += 1\n }\n ;(result[i] as T[]).push(e)\n })\n return result\n}\n\n/**\n * Unique an Array\n *\n * @category Array\n * @example\n * ```ts\n * uniq([1, 2, 3, 3, 2, 1]) // [1, 2, 3]\n * ```\n */\nexport function uniq<T>(array: readonly T[]): T[] {\n return Array.from(new Set(array))\n}\n\n/**\n * Unique an Array\n *\n * @param array\n * @example\n * ```ts\n * unique([1, 2, 3, 3, 2, 1]) // [1, 2, 3]\n * ```\n */\nexport function unique<T>(array: readonly T[]): T[] {\n return uniq(array)\n}\n\n/**\n * Unique an Array by a custom equality function\n *\n * @category Array\n * @example\n * ```ts\n * uniqueBy([1, 2, 3, 3, 2, 1], (a, b) => a === b) // [1, 2, 3]\n * ```\n */\nexport function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[] {\n return array.reduce((acc: T[], cur: any) => {\n const index = acc.findIndex((item: any) => equalFn(cur, item))\n if (index === -1)\n acc.push(cur)\n return acc\n }, [])\n}\n\n/**\n * Get last item\n *\n * @category Array\n * @example\n * ```ts\n * last([1, 2, 3]) // 3\n * ```\n */\nexport function last(array: readonly []): undefined\nexport function last<T>(array: readonly T[]): T\nexport function last<T>(array: readonly T[]): T | undefined {\n return at(array, -1)\n}\n\n/**\n * Remove an item from Array\n *\n * @category Array\n * @example\n * ```ts\n * const arr = [1, 2, 3]\n * remove(arr, 2) // true\n * Arr.remove(arr, 4) // false\n * console.log(arr) // [1, 3]\n */\nexport function remove<T>(array: T[], value: T): boolean {\n if (!array)\n return false\n\n const index = array.indexOf(value)\n if (index >= 0) {\n array.splice(index, 1)\n return true\n }\n\n return false\n}\n\n/**\n * Get nth item of Array. Negative for backward\n *\n * @category Array\n * @example\n * ```ts\n * at([1, 2, 3], 1) // 2\n * at([1, 2, 3], -1) // 3\n * at([1, 2, 3], 3) // undefined\n * at([1, 2, 3], -4) // undefined\n * ```\n */\nexport function at(array: readonly [], index: number): undefined\nexport function at<T>(array: readonly T[], index: number): T\nexport function at<T>(array: readonly T[] | [], index: number): T | undefined {\n const len = array.length\n if (!len)\n return undefined\n\n if (index < 0)\n index += len\n\n return array[index]\n}\n\n/**\n * Move an item from one index to another\n * @param array\n * @param from\n * @param to\n *\n * @category Array\n * @example\n * ```ts\n * move([1, 2, 3, 4], 0, 2) // [2, 3, 1, 4]\n * move([1, 2, 3, 4], 0, -1) // [2, 3, 4, 1]\n * move([1, 2, 3, 4], -1, 0) // [4, 1, 2, 3]\n * move([1, 2, 3, 4], -1, -2) // [1, 4, 2, 3]\n * move([1, 2, 3, 4], 1, 1) // [1, 2, 3, 4]\n * ```\n */\nexport function move<T>(array: T[], from: number, to: number): T[] {\n const len = array.length\n if (!len)\n return []\n\n if (from < 0)\n from += len\n\n if (to < 0)\n to += len\n\n const item = array.splice(from, 1)[0]\n array.splice(to, 0, item as T)\n return array\n}\n\n/**\n * Clamp a number to the index range of an array.\n *\n * @category Array\n * @example\n * ```ts\n * clampArrayRange([1, 2, 3], 0) // 0\n * clampArrayRange([1, 2, 3], 1) // 1\n * clampArrayRange([1, 2, 3], 2) // 2\n * clampArrayRange([1, 2, 3], 3) // 2\n * clampArrayRange([1, 2, 3], 4) // 2\n * clampArrayRange([1, 2, 3], -1) // 0\n */\nexport function clampArrayRange(arr: readonly unknown[], n: number): number {\n return clamp(n, 0, arr.length - 1)\n}\n\n/**\n * Get random items from an array\n *\n * @category Array\n * @example\n * ```ts\n * sample([1, 2, 3, 4], 2) // [2, 3]\n * ```\n */\nexport function sample<T>(arr: T[], count: number): T[] {\n return Array.from({ length: count }, () => arr[Math.floor(Math.random() * arr.length)]!)\n}\n\n/**\n * Shuffle an array. This function mutates the array.\n *\n * @category Array\n * @example\n * ```ts\n * shuffle([1, 2, 3, 4]) // [2, 4, 1, 3]\n * ```\n */\nexport function shuffle<T>(array: T[]): T[] {\n for (let i = array.length - 1; i > 0; i--) {\n const j = Math.floor(Math.random() * (i + 1))\n ;[array[i] as T, array[j] as T] = [array[j] as T, array[i] as T]\n }\n return array\n}\n",
|
|
7
|
+
"/**\n * Returns the average of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * average([1, 2, 3, 4]) // 2.5\n * ```\n */\nexport function average(arr: number[]): number {\n return sum(arr) / arr.length\n}\n\n/**\n * Returns the average of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * avg([1, 2, 3, 4]) // 2.5\n * ```\n */\nexport function avg(arr: number[]): number {\n return average(arr)\n}\n\n/**\n * Returns the median of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * median([1, 2, 3, 4]) // 2.5\n * ```\n */\nexport function median(arr: number[]): number {\n if (arr.length === 0)\n throw new Error('Cannot compute median of an empty array')\n\n const sorted = [...arr].sort((a, b) => a - b)\n\n const mid = Math.floor(sorted.length / 2)\n\n let medianValue: number\n\n if (sorted.length % 2 !== 0)\n medianValue = sorted[mid] as number\n else medianValue = ((sorted[mid] as number) + (sorted[mid - 1] as number)) / 2 // or (sorted[mid - 1] + sorted[mid]) / 2\n\n return medianValue\n}\n\n/**\n * Returns the mode of an array of numbers\n * @param arr\n * @category Array\n * @example\n * ```ts\n * mode([1, 2, 3, 4]) // 1\n * mode([1, 2, 2, 3, 4]) // 2\n * mode([1, 2, 2, 3, 3, 4]) // 2\n * mode([1, 2, 2, 3, 3, 4, 4]) // 2\n * mode([1, 2, 2, 3, 3, 4, 4, 4]) // 4\n * ```\n */\nexport function mode(arr: number[]): number {\n return arr.sort((a, b) => arr.filter(v => v === a).length - arr.filter(v => v === b).length).pop() as number\n}\n\n/**\n * Returns the sum of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * sum([1, 2, 3, 4]) // 10\n * ```\n */\nexport function sum(array: readonly number[]): number {\n return array.reduce((acc, cur) => acc + cur, 0)\n}\n\n/**\n * Returns the product of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * product([1, 2, 3, 4]) // 24\n * ```\n */\nexport function product(array: readonly number[]): number {\n return array.reduce((acc, cur) => acc * cur, 1)\n}\n\n/**\n * Returns the minimum value of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * min([1, 2, 3, 4]) // 1\n * min([1, 2, 3, 4, -1]) // -1\n * ```\n */\nexport function min(array: readonly number[]): number {\n return Math.min(...array)\n}\n\n/**\n * Returns the maximum value of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * max([1, 2, 3, 4]) // 4\n * max([1, 2, 3, 4, -1]) // 4\n * ```\n */\nexport function max(array: readonly number[]): number {\n return Math.max(...array)\n}\n\n/**\n * Returns the range of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * range([1, 2, 3, 4]) // 3\n * range([1, 2, 3, 4, -1]) // 5\n * range([1, 2, 3, 4, -1, 10]) // 11\n * ```\n */\nexport function range(array: readonly number[]): number {\n return max(array) - min(array)\n}\n\n/**\n * Returns the variance of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * variance([1, 2, 3, 4]) // 1.25\n * ```\n * @see https://en.wikipedia.org/wiki/Variance\n */\nexport function variance(array: number[]): number {\n const mean = average(array)\n return average(array.map(num => (num - mean) ** 2))\n}\n\n/**\n * Returns the standard deviation of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * standardDeviation([1, 2, 3, 4]) // 1.118033988749895\n * ```\n * @see https://en.wikipedia.org/wiki/Standard_deviation\n * @see https://stackoverflow.com/questions/7343890/standard-deviation-javascript\n */\nexport function standardDeviation(array: number[]): number {\n return Math.sqrt(variance(array))\n}\n\n/**\n * Returns the z-score of a number in an array of numbers\n * @param array\n * @param num\n * @category Array\n * @example\n * ```ts\n * zScore([1, 2, 3, 4], 2) // 0\n * zScore([1, 2, 3, 4], 3) // 0.7071067811865475\n * ```\n * @see https://en.wikipedia.org/wiki/Standard_score\n */\nexport function zScore(array: number[], num: number): number {\n return (num - average(array)) / standardDeviation(array)\n}\n\n/**\n * Returns the percentile of a number in an array of numbers\n * @param array\n * @param num\n * @category Array\n * @example\n * ```ts\n * percentile([1, 2, 3, 4], 2) // 0.25\n * percentile([1, 2, 3, 4], 3) // 0.75\n * ```\n * @see https://en.wikipedia.org/wiki/Percentile\n */\nexport function percentile(array: number[], num: number): number {\n const sorted = [...array].sort((a, b) => a - b)\n const index = (num / 100) * (sorted.length - 1)\n const lower = Math.floor(index)\n const upper = Math.ceil(index)\n const weight = index - lower\n\n if (upper === lower)\n return sorted[index] ?? 0\n return (1 - weight) * (sorted[lower] ?? 0) + weight * (sorted[upper] ?? 0)\n}\n\n/**\n * Returns the interquartile range of an array of numbers\n * @param array\n * @category Array\n * @example\n * ```ts\n * interquartileRange([1, 2, 3, 4]) // 1.5\n * ```\n * @see https://en.wikipedia.org/wiki/Interquartile_range\n * @see https://stackoverflow.com/questions/48719873/how-to-calculate-interquartile-range-in-javascript\n */\nexport function interquartileRange(array: number[]): number {\n const q1 = median(array.slice(0, Math.floor(array.length / 2)))\n const q3 = median(array.slice(Math.ceil(array.length / 2)))\n return q3 - q1\n}\n\n/**\n * Returns the covariance of two arrays of numbers\n * @param array1\n * @param array2\n * @category Array\n * @example\n * ```ts\n * covariance([1, 2, 3, 4], [1, 2, 3, 4]) // 1.25\n * covariance([1, 2, 3, 4], [4, 3, 2, 1]) // -1.25\n * ```\n */\nexport function covariance(array1: number[], array2: number[]): number {\n if (array1.length !== array2.length)\n throw new Error('Arrays must have the same length')\n\n const mean1 = average(array1)\n const mean2 = average(array2)\n\n return average(array1.map((num1, i) => (num1 - mean1) * ((array2[i] as number) - mean2)))\n}\n",
|
|
8
|
+
"import type { Arrayable, Nullable } from '@stacksjs/types'\nimport type { PartitionFilter } from './helpers'\nimport { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'\nimport {\n at,\n clampArrayRange,\n flatten,\n last,\n mergeArrayable,\n move,\n partition,\n remove,\n sample,\n shuffle,\n toArray,\n uniq,\n uniqueBy,\n} from './helpers'\nimport { average, median, mode, range, sum } from './math'\n\nexport const Arr = {\n contains(needle: string, haystack: string[]): boolean {\n return contains(needle, haystack)\n },\n\n containsAll(needles: string[], haystack: string[]): boolean {\n return containsAll(needles, haystack)\n },\n\n containsAny(needles: string[], haystack: string[]): boolean {\n return containsAny(needles, haystack)\n },\n\n containsNone(needles: string[], haystack: string[]): boolean {\n return containsNone(needles, haystack)\n },\n\n containsOnly(needles: string[], haystack: string[]): boolean {\n return containsOnly(needles, haystack)\n },\n\n doesNotContain(needle: string, haystack: string[]): boolean {\n return doesNotContain(needle, haystack)\n },\n\n toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {\n return toArray(array)\n },\n\n flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[] {\n return flatten(array)\n },\n\n mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T> {\n return mergeArrayable(...args)\n },\n\n partition<T>(array: readonly T[], filter: PartitionFilter<T>): [T[], T[]] {\n return partition(array, filter)\n },\n\n /**\n * Returns a random item/s from the array\n */\n random<T>(arr: T[], count = 1): T[] {\n return sample(arr, count).filter((item): item is T => item != null)\n },\n\n /**\n * Returns random item/s from the array\n */\n sample<T>(arr: T[], count = 1): T[] {\n return sample(arr, count)\n },\n\n unique<T>(arr: T[]): T[] {\n return uniq(arr)\n },\n\n uniqueBy<T>(arr: readonly T[], equalFn: (a: any, b: any) => boolean): T[] {\n return uniqueBy(arr, equalFn)\n },\n\n last<T>(arr: T[]): T | undefined {\n return last(arr)\n },\n\n remove<T>(arr: T[], value: T): boolean {\n return remove(arr, value)\n },\n\n at(arr: any[], index: number): any {\n return at(arr, index)\n },\n\n range(arr: readonly number[]): number {\n return range(arr)\n },\n\n move<T>(arr: T[], from: number, to: number): T[] {\n return move(arr, from, to)\n },\n\n clampArrayRange(arr: readonly unknown[], n: number): number {\n return clampArrayRange(arr, n)\n },\n\n shuffle<T>(arr: T[]): T[] {\n return shuffle(arr)\n },\n\n /**\n * Returns the sum of all items in the array\n */\n sum(arr: number[]): number {\n return sum(arr)\n },\n\n /**\n * Returns the average of all items in the array\n */\n average(arr: number[]): number {\n return average(arr)\n },\n\n avg(arr: number[]): number {\n return average(arr)\n },\n\n /**\n * Returns the median of all items in the array\n */\n median(arr: number[]): number {\n return median(arr)\n },\n\n /**\n * Returns the mode of all items in the array\n */\n mode(arr: number[]): number {\n return mode(arr)\n },\n}\n\nexport const arr: typeof Arr = Arr\n"
|
|
9
9
|
],
|
|
10
|
-
"mappings": ";
|
|
11
|
-
"debugId": "
|
|
10
|
+
"mappings": "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",
|
|
11
|
+
"debugId": "B6B872CC06F3654D64756E2164756E21",
|
|
12
12
|
"names": []
|
|
13
13
|
}
|
package/dist/macro.d.ts
ADDED
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import type { Arrayable, Nullable } from "@stacksjs/types";
|
|
2
|
+
import type { PartitionFilter } from "./helpers";
|
|
3
|
+
export declare const Arr: {
|
|
4
|
+
contains(needle: string, haystack: string[]): boolean;
|
|
5
|
+
containsAll(needles: string[], haystack: string[]): boolean;
|
|
6
|
+
containsAny(needles: string[], haystack: string[]): boolean;
|
|
7
|
+
containsNone(needles: string[], haystack: string[]): boolean;
|
|
8
|
+
containsOnly(needles: string[], haystack: string[]): boolean;
|
|
9
|
+
doesNotContain(needle: string, haystack: string[]): boolean;
|
|
10
|
+
toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
|
|
11
|
+
flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[];
|
|
12
|
+
mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T>;
|
|
13
|
+
partition<T>(array: readonly T[], filter: PartitionFilter<T>): [T[], T[]];
|
|
14
|
+
random<T>(arr: T[], count?: number): T[];
|
|
15
|
+
sample<T>(arr: T[], count?: number): T[];
|
|
16
|
+
unique<T>(arr: T[]): T[];
|
|
17
|
+
uniqueBy<T>(arr: readonly T[], equalFn: (a: any, b: any) => boolean): T[];
|
|
18
|
+
last<T>(arr: T[]): T | undefined;
|
|
19
|
+
remove<T>(arr: T[], value: T): boolean;
|
|
20
|
+
at(arr: any[], index: number): any;
|
|
21
|
+
range(arr: readonly number[]): number;
|
|
22
|
+
move<T>(arr: T[], from: number, to: number): T[];
|
|
23
|
+
clampArrayRange(arr: readonly unknown[], n: number): number;
|
|
24
|
+
shuffle<T>(arr: T[]): T[];
|
|
25
|
+
sum(arr: number[]): number;
|
|
26
|
+
average(arr: number[]): number;
|
|
27
|
+
avg(arr: number[]): number;
|
|
28
|
+
median(arr: number[]): number;
|
|
29
|
+
mode(arr: number[]): number;
|
|
30
|
+
};
|
|
31
|
+
export declare const arr: typeof Arr;
|
package/dist/math.d.ts
ADDED
|
@@ -0,0 +1,171 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Returns the average of an array of numbers
|
|
3
|
+
* @param arr
|
|
4
|
+
* @category Array
|
|
5
|
+
* @example
|
|
6
|
+
* ```ts
|
|
7
|
+
* average([1, 2, 3, 4]) // 2.5
|
|
8
|
+
* ```
|
|
9
|
+
*/
|
|
10
|
+
export declare function average(arr: number[]): number;
|
|
11
|
+
/**
|
|
12
|
+
* Returns the average of an array of numbers
|
|
13
|
+
* @param arr
|
|
14
|
+
* @category Array
|
|
15
|
+
* @example
|
|
16
|
+
* ```ts
|
|
17
|
+
* avg([1, 2, 3, 4]) // 2.5
|
|
18
|
+
* ```
|
|
19
|
+
*/
|
|
20
|
+
export declare function avg(arr: number[]): number;
|
|
21
|
+
/**
|
|
22
|
+
* Returns the median of an array of numbers
|
|
23
|
+
* @param arr
|
|
24
|
+
* @category Array
|
|
25
|
+
* @example
|
|
26
|
+
* ```ts
|
|
27
|
+
* median([1, 2, 3, 4]) // 2.5
|
|
28
|
+
* ```
|
|
29
|
+
*/
|
|
30
|
+
export declare function median(arr: number[]): number;
|
|
31
|
+
/**
|
|
32
|
+
* Returns the mode of an array of numbers
|
|
33
|
+
* @param arr
|
|
34
|
+
* @category Array
|
|
35
|
+
* @example
|
|
36
|
+
* ```ts
|
|
37
|
+
* mode([1, 2, 3, 4]) // 1
|
|
38
|
+
* mode([1, 2, 2, 3, 4]) // 2
|
|
39
|
+
* mode([1, 2, 2, 3, 3, 4]) // 2
|
|
40
|
+
* mode([1, 2, 2, 3, 3, 4, 4]) // 2
|
|
41
|
+
* mode([1, 2, 2, 3, 3, 4, 4, 4]) // 4
|
|
42
|
+
* ```
|
|
43
|
+
*/
|
|
44
|
+
export declare function mode(arr: number[]): number;
|
|
45
|
+
/**
|
|
46
|
+
* Returns the sum of an array of numbers
|
|
47
|
+
* @param array
|
|
48
|
+
* @category Array
|
|
49
|
+
* @example
|
|
50
|
+
* ```ts
|
|
51
|
+
* sum([1, 2, 3, 4]) // 10
|
|
52
|
+
* ```
|
|
53
|
+
*/
|
|
54
|
+
export declare function sum(array: readonly number[]): number;
|
|
55
|
+
/**
|
|
56
|
+
* Returns the product of an array of numbers
|
|
57
|
+
* @param array
|
|
58
|
+
* @category Array
|
|
59
|
+
* @example
|
|
60
|
+
* ```ts
|
|
61
|
+
* product([1, 2, 3, 4]) // 24
|
|
62
|
+
* ```
|
|
63
|
+
*/
|
|
64
|
+
export declare function product(array: readonly number[]): number;
|
|
65
|
+
/**
|
|
66
|
+
* Returns the minimum value of an array of numbers
|
|
67
|
+
* @param array
|
|
68
|
+
* @category Array
|
|
69
|
+
* @example
|
|
70
|
+
* ```ts
|
|
71
|
+
* min([1, 2, 3, 4]) // 1
|
|
72
|
+
* min([1, 2, 3, 4, -1]) // -1
|
|
73
|
+
* ```
|
|
74
|
+
*/
|
|
75
|
+
export declare function min(array: readonly number[]): number;
|
|
76
|
+
/**
|
|
77
|
+
* Returns the maximum value of an array of numbers
|
|
78
|
+
* @param array
|
|
79
|
+
* @category Array
|
|
80
|
+
* @example
|
|
81
|
+
* ```ts
|
|
82
|
+
* max([1, 2, 3, 4]) // 4
|
|
83
|
+
* max([1, 2, 3, 4, -1]) // 4
|
|
84
|
+
* ```
|
|
85
|
+
*/
|
|
86
|
+
export declare function max(array: readonly number[]): number;
|
|
87
|
+
/**
|
|
88
|
+
* Returns the range of an array of numbers
|
|
89
|
+
* @param array
|
|
90
|
+
* @category Array
|
|
91
|
+
* @example
|
|
92
|
+
* ```ts
|
|
93
|
+
* range([1, 2, 3, 4]) // 3
|
|
94
|
+
* range([1, 2, 3, 4, -1]) // 5
|
|
95
|
+
* range([1, 2, 3, 4, -1, 10]) // 11
|
|
96
|
+
* ```
|
|
97
|
+
*/
|
|
98
|
+
export declare function range(array: readonly number[]): number;
|
|
99
|
+
/**
|
|
100
|
+
* Returns the variance of an array of numbers
|
|
101
|
+
* @param array
|
|
102
|
+
* @category Array
|
|
103
|
+
* @example
|
|
104
|
+
* ```ts
|
|
105
|
+
* variance([1, 2, 3, 4]) // 1.25
|
|
106
|
+
* ```
|
|
107
|
+
* @see https://en.wikipedia.org/wiki/Variance
|
|
108
|
+
*/
|
|
109
|
+
export declare function variance(array: number[]): number;
|
|
110
|
+
/**
|
|
111
|
+
* Returns the standard deviation of an array of numbers
|
|
112
|
+
* @param array
|
|
113
|
+
* @category Array
|
|
114
|
+
* @example
|
|
115
|
+
* ```ts
|
|
116
|
+
* standardDeviation([1, 2, 3, 4]) // 1.118033988749895
|
|
117
|
+
* ```
|
|
118
|
+
* @see https://en.wikipedia.org/wiki/Standard_deviation
|
|
119
|
+
* @see https://stackoverflow.com/questions/7343890/standard-deviation-javascript
|
|
120
|
+
*/
|
|
121
|
+
export declare function standardDeviation(array: number[]): number;
|
|
122
|
+
/**
|
|
123
|
+
* Returns the z-score of a number in an array of numbers
|
|
124
|
+
* @param array
|
|
125
|
+
* @param num
|
|
126
|
+
* @category Array
|
|
127
|
+
* @example
|
|
128
|
+
* ```ts
|
|
129
|
+
* zScore([1, 2, 3, 4], 2) // 0
|
|
130
|
+
* zScore([1, 2, 3, 4], 3) // 0.7071067811865475
|
|
131
|
+
* ```
|
|
132
|
+
* @see https://en.wikipedia.org/wiki/Standard_score
|
|
133
|
+
*/
|
|
134
|
+
export declare function zScore(array: number[], num: number): number;
|
|
135
|
+
/**
|
|
136
|
+
* Returns the percentile of a number in an array of numbers
|
|
137
|
+
* @param array
|
|
138
|
+
* @param num
|
|
139
|
+
* @category Array
|
|
140
|
+
* @example
|
|
141
|
+
* ```ts
|
|
142
|
+
* percentile([1, 2, 3, 4], 2) // 0.25
|
|
143
|
+
* percentile([1, 2, 3, 4], 3) // 0.75
|
|
144
|
+
* ```
|
|
145
|
+
* @see https://en.wikipedia.org/wiki/Percentile
|
|
146
|
+
*/
|
|
147
|
+
export declare function percentile(array: number[], num: number): number;
|
|
148
|
+
/**
|
|
149
|
+
* Returns the interquartile range of an array of numbers
|
|
150
|
+
* @param array
|
|
151
|
+
* @category Array
|
|
152
|
+
* @example
|
|
153
|
+
* ```ts
|
|
154
|
+
* interquartileRange([1, 2, 3, 4]) // 1.5
|
|
155
|
+
* ```
|
|
156
|
+
* @see https://en.wikipedia.org/wiki/Interquartile_range
|
|
157
|
+
* @see https://stackoverflow.com/questions/48719873/how-to-calculate-interquartile-range-in-javascript
|
|
158
|
+
*/
|
|
159
|
+
export declare function interquartileRange(array: number[]): number;
|
|
160
|
+
/**
|
|
161
|
+
* Returns the covariance of two arrays of numbers
|
|
162
|
+
* @param array1
|
|
163
|
+
* @param array2
|
|
164
|
+
* @category Array
|
|
165
|
+
* @example
|
|
166
|
+
* ```ts
|
|
167
|
+
* covariance([1, 2, 3, 4], [1, 2, 3, 4]) // 1.25
|
|
168
|
+
* covariance([1, 2, 3, 4], [4, 3, 2, 1]) // -1.25
|
|
169
|
+
* ```
|
|
170
|
+
*/
|
|
171
|
+
export declare function covariance(array1: number[], array2: number[]): number;
|
package/package.json
CHANGED
|
@@ -1,9 +1,10 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@stacksjs/arrays",
|
|
3
3
|
"type": "module",
|
|
4
|
-
"version": "0.
|
|
4
|
+
"version": "0.65.0",
|
|
5
5
|
"description": "The Stacks array utilities.",
|
|
6
6
|
"author": "Chris Breuer",
|
|
7
|
+
"contributors": ["Chris Breuer <chris@stacksjs.org>"],
|
|
7
8
|
"license": "MIT",
|
|
8
9
|
"funding": "https://github.com/sponsors/chrisbbreuer",
|
|
9
10
|
"homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/arrays#readme",
|
|
@@ -35,23 +36,17 @@
|
|
|
35
36
|
},
|
|
36
37
|
"module": "dist/index.js",
|
|
37
38
|
"types": "dist/index.d.ts",
|
|
38
|
-
"
|
|
39
|
-
"Chris Breuer <chris@stacksjs.org>"
|
|
40
|
-
],
|
|
41
|
-
"files": [
|
|
42
|
-
"README.md",
|
|
43
|
-
"dist",
|
|
44
|
-
"src"
|
|
45
|
-
],
|
|
39
|
+
"files": ["README.md", "dist", "src"],
|
|
46
40
|
"scripts": {
|
|
47
|
-
"build": "bun
|
|
48
|
-
"typecheck": "bun
|
|
41
|
+
"build": "bun build.ts",
|
|
42
|
+
"typecheck": "bun tsc --noEmit",
|
|
43
|
+
"test": "bun test",
|
|
49
44
|
"prepublishOnly": "bun run build"
|
|
50
45
|
},
|
|
51
46
|
"dependencies": {
|
|
52
|
-
"@stacksjs/utils": "
|
|
47
|
+
"@stacksjs/utils": "0.64.6"
|
|
53
48
|
},
|
|
54
49
|
"devDependencies": {
|
|
55
|
-
"@stacksjs/development": "
|
|
50
|
+
"@stacksjs/development": "0.64.6"
|
|
56
51
|
}
|
|
57
52
|
}
|
package/src/arr.ts
CHANGED
package/src/contains.ts
CHANGED
|
@@ -9,8 +9,8 @@
|
|
|
9
9
|
* contains('foo', ['bar']) // false
|
|
10
10
|
* ```
|
|
11
11
|
*/
|
|
12
|
-
export function contains(needle: string, haystack: string[]) {
|
|
13
|
-
return haystack.some(
|
|
12
|
+
export function contains(needle: string, haystack: string[]): boolean {
|
|
13
|
+
return haystack.some(hay => needle.includes(hay))
|
|
14
14
|
}
|
|
15
15
|
|
|
16
16
|
/**
|
|
@@ -23,8 +23,8 @@ export function contains(needle: string, haystack: string[]) {
|
|
|
23
23
|
* containsAll(['foo', 'bar'], ['foo', 'baz']) // false
|
|
24
24
|
* ```
|
|
25
25
|
*/
|
|
26
|
-
export function containsAll(needles: string[], haystack: string[]) {
|
|
27
|
-
return needles.every(
|
|
26
|
+
export function containsAll(needles: string[], haystack: string[]): boolean {
|
|
27
|
+
return needles.every(needle => contains(needle, haystack))
|
|
28
28
|
}
|
|
29
29
|
|
|
30
30
|
/**
|
|
@@ -38,8 +38,8 @@ export function containsAll(needles: string[], haystack: string[]) {
|
|
|
38
38
|
* containsAny(['foo', 'bar'], ['baz']) // false
|
|
39
39
|
* ```
|
|
40
40
|
*/
|
|
41
|
-
export function containsAny(needles: string[], haystack: string[]) {
|
|
42
|
-
return needles.some(
|
|
41
|
+
export function containsAny(needles: string[], haystack: string[]): boolean {
|
|
42
|
+
return needles.some(needle => contains(needle, haystack))
|
|
43
43
|
}
|
|
44
44
|
|
|
45
45
|
/**
|
|
@@ -53,7 +53,7 @@ export function containsAny(needles: string[], haystack: string[]) {
|
|
|
53
53
|
* containsNone(['foo', 'bar'], ['baz']) // true
|
|
54
54
|
* ```
|
|
55
55
|
*/
|
|
56
|
-
export function containsNone(needles: string[], haystack: string[]) {
|
|
56
|
+
export function containsNone(needles: string[], haystack: string[]): boolean {
|
|
57
57
|
return !containsAny(needles, haystack)
|
|
58
58
|
}
|
|
59
59
|
|
|
@@ -68,7 +68,7 @@ export function containsNone(needles: string[], haystack: string[]) {
|
|
|
68
68
|
* containsOnly(['foo', 'bar'], ['foo', 'bar']) // true
|
|
69
69
|
* ```
|
|
70
70
|
*/
|
|
71
|
-
export function containsOnly(needles: string[], haystack: string[]) {
|
|
71
|
+
export function containsOnly(needles: string[], haystack: string[]): boolean {
|
|
72
72
|
return containsAll(haystack, needles)
|
|
73
73
|
}
|
|
74
74
|
|
|
@@ -82,6 +82,6 @@ export function containsOnly(needles: string[], haystack: string[]) {
|
|
|
82
82
|
* doesNotContain('foo', ['bar']) // true
|
|
83
83
|
* ```
|
|
84
84
|
*/
|
|
85
|
-
export function doesNotContain(needle: string, haystack: string[]) {
|
|
85
|
+
export function doesNotContain(needle: string, haystack: string[]): boolean {
|
|
86
86
|
return !contains(needle, haystack)
|
|
87
87
|
}
|
package/src/helpers.ts
CHANGED
|
@@ -31,8 +31,8 @@ export function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {
|
|
|
31
31
|
* flatten([1, [2, [3, [4, [5]]]]]) // [1, 2, 3, 4, 5]
|
|
32
32
|
* ```
|
|
33
33
|
*/
|
|
34
|
-
export function flatten<T>(array?: Nullable<Arrayable<T |
|
|
35
|
-
return toArray(array).
|
|
34
|
+
export function flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[] {
|
|
35
|
+
return toArray(array).reduce((acc: T[], val) => acc.concat(Array.isArray(val) ? flatten(val) : (val as T)), [])
|
|
36
36
|
}
|
|
37
37
|
|
|
38
38
|
/**
|
|
@@ -45,7 +45,7 @@ export function flatten<T>(array?: Nullable<Arrayable<T | Array<T>>>): Array<T>
|
|
|
45
45
|
* ```
|
|
46
46
|
*/
|
|
47
47
|
export function mergeArrayable<T>(...args: Nullable<Arrayable<T>>[]): Array<T> {
|
|
48
|
-
return args.flatMap(
|
|
48
|
+
return args.flatMap(i => toArray(i))
|
|
49
49
|
}
|
|
50
50
|
|
|
51
51
|
export type PartitionFilter<T> = (i: T, idx: number, arr: readonly T[]) => any
|
|
@@ -150,7 +150,8 @@ export function unique<T>(array: readonly T[]): T[] {
|
|
|
150
150
|
export function uniqueBy<T>(array: readonly T[], equalFn: (a: any, b: any) => boolean): T[] {
|
|
151
151
|
return array.reduce((acc: T[], cur: any) => {
|
|
152
152
|
const index = acc.findIndex((item: any) => equalFn(cur, item))
|
|
153
|
-
if (index === -1)
|
|
153
|
+
if (index === -1)
|
|
154
|
+
acc.push(cur)
|
|
154
155
|
return acc
|
|
155
156
|
}, [])
|
|
156
157
|
}
|
|
@@ -181,8 +182,9 @@ export function last<T>(array: readonly T[]): T | undefined {
|
|
|
181
182
|
* Arr.remove(arr, 4) // false
|
|
182
183
|
* console.log(arr) // [1, 3]
|
|
183
184
|
*/
|
|
184
|
-
export function remove<T>(array: T[], value: T) {
|
|
185
|
-
if (!array)
|
|
185
|
+
export function remove<T>(array: T[], value: T): boolean {
|
|
186
|
+
if (!array)
|
|
187
|
+
return false
|
|
186
188
|
|
|
187
189
|
const index = array.indexOf(value)
|
|
188
190
|
if (index >= 0) {
|
|
@@ -209,9 +211,11 @@ export function at(array: readonly [], index: number): undefined
|
|
|
209
211
|
export function at<T>(array: readonly T[], index: number): T
|
|
210
212
|
export function at<T>(array: readonly T[] | [], index: number): T | undefined {
|
|
211
213
|
const len = array.length
|
|
212
|
-
if (!len)
|
|
214
|
+
if (!len)
|
|
215
|
+
return undefined
|
|
213
216
|
|
|
214
|
-
if (index < 0)
|
|
217
|
+
if (index < 0)
|
|
218
|
+
index += len
|
|
215
219
|
|
|
216
220
|
return array[index]
|
|
217
221
|
}
|
|
@@ -234,11 +238,14 @@ export function at<T>(array: readonly T[] | [], index: number): T | undefined {
|
|
|
234
238
|
*/
|
|
235
239
|
export function move<T>(array: T[], from: number, to: number): T[] {
|
|
236
240
|
const len = array.length
|
|
237
|
-
if (!len)
|
|
241
|
+
if (!len)
|
|
242
|
+
return []
|
|
238
243
|
|
|
239
|
-
if (from < 0)
|
|
244
|
+
if (from < 0)
|
|
245
|
+
from += len
|
|
240
246
|
|
|
241
|
-
if (to < 0)
|
|
247
|
+
if (to < 0)
|
|
248
|
+
to += len
|
|
242
249
|
|
|
243
250
|
const item = array.splice(from, 1)[0]
|
|
244
251
|
array.splice(to, 0, item as T)
|
|
@@ -258,7 +265,7 @@ export function move<T>(array: T[], from: number, to: number): T[] {
|
|
|
258
265
|
* clampArrayRange([1, 2, 3], 4) // 2
|
|
259
266
|
* clampArrayRange([1, 2, 3], -1) // 0
|
|
260
267
|
*/
|
|
261
|
-
export function clampArrayRange(arr: readonly unknown[], n: number) {
|
|
268
|
+
export function clampArrayRange(arr: readonly unknown[], n: number): number {
|
|
262
269
|
return clamp(n, 0, arr.length - 1)
|
|
263
270
|
}
|
|
264
271
|
|
|
@@ -271,8 +278,8 @@ export function clampArrayRange(arr: readonly unknown[], n: number) {
|
|
|
271
278
|
* sample([1, 2, 3, 4], 2) // [2, 3]
|
|
272
279
|
* ```
|
|
273
280
|
*/
|
|
274
|
-
export function sample<T>(arr: T[], count: number) {
|
|
275
|
-
return Array.from({ length: count }, (
|
|
281
|
+
export function sample<T>(arr: T[], count: number): T[] {
|
|
282
|
+
return Array.from({ length: count }, () => arr[Math.floor(Math.random() * arr.length)]!)
|
|
276
283
|
}
|
|
277
284
|
|
|
278
285
|
/**
|
package/src/macro.ts
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import type { Arrayable, Nullable } from '@stacksjs/types'
|
|
2
|
-
import { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'
|
|
3
2
|
import type { PartitionFilter } from './helpers'
|
|
3
|
+
import { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from './contains'
|
|
4
4
|
import {
|
|
5
5
|
at,
|
|
6
6
|
clampArrayRange,
|
|
@@ -19,27 +19,27 @@ import {
|
|
|
19
19
|
import { average, median, mode, range, sum } from './math'
|
|
20
20
|
|
|
21
21
|
export const Arr = {
|
|
22
|
-
contains(needle: string, haystack: string[]) {
|
|
22
|
+
contains(needle: string, haystack: string[]): boolean {
|
|
23
23
|
return contains(needle, haystack)
|
|
24
24
|
},
|
|
25
25
|
|
|
26
|
-
containsAll(needles: string[], haystack: string[]) {
|
|
26
|
+
containsAll(needles: string[], haystack: string[]): boolean {
|
|
27
27
|
return containsAll(needles, haystack)
|
|
28
28
|
},
|
|
29
29
|
|
|
30
|
-
containsAny(needles: string[], haystack: string[]) {
|
|
30
|
+
containsAny(needles: string[], haystack: string[]): boolean {
|
|
31
31
|
return containsAny(needles, haystack)
|
|
32
32
|
},
|
|
33
33
|
|
|
34
|
-
containsNone(needles: string[], haystack: string[]) {
|
|
34
|
+
containsNone(needles: string[], haystack: string[]): boolean {
|
|
35
35
|
return containsNone(needles, haystack)
|
|
36
36
|
},
|
|
37
37
|
|
|
38
|
-
containsOnly(needles: string[], haystack: string[]) {
|
|
38
|
+
containsOnly(needles: string[], haystack: string[]): boolean {
|
|
39
39
|
return containsOnly(needles, haystack)
|
|
40
40
|
},
|
|
41
41
|
|
|
42
|
-
doesNotContain(needle: string, haystack: string[]) {
|
|
42
|
+
doesNotContain(needle: string, haystack: string[]): boolean {
|
|
43
43
|
return doesNotContain(needle, haystack)
|
|
44
44
|
},
|
|
45
45
|
|
|
@@ -47,7 +47,7 @@ export const Arr = {
|
|
|
47
47
|
return toArray(array)
|
|
48
48
|
},
|
|
49
49
|
|
|
50
|
-
flatten<T>(array?: Nullable<Arrayable<T |
|
|
50
|
+
flatten<T>(array?: Nullable<Arrayable<T | T[]>>): T[] {
|
|
51
51
|
return flatten(array)
|
|
52
52
|
},
|
|
53
53
|
|
|
@@ -70,11 +70,7 @@ export const Arr = {
|
|
|
70
70
|
* Returns random item/s from the array
|
|
71
71
|
*/
|
|
72
72
|
sample<T>(arr: T[], count = 1): T[] {
|
|
73
|
-
|
|
74
|
-
const sampleArr = sample(arr, count)
|
|
75
|
-
|
|
76
|
-
// Filter out any undefined values
|
|
77
|
-
return sampleArr.filter((item): item is T => item !== undefined)
|
|
73
|
+
return sample(arr, count)
|
|
78
74
|
},
|
|
79
75
|
|
|
80
76
|
unique<T>(arr: T[]): T[] {
|
|
@@ -89,7 +85,7 @@ export const Arr = {
|
|
|
89
85
|
return last(arr)
|
|
90
86
|
},
|
|
91
87
|
|
|
92
|
-
remove<T>(arr: T[], value: T) {
|
|
88
|
+
remove<T>(arr: T[], value: T): boolean {
|
|
93
89
|
return remove(arr, value)
|
|
94
90
|
},
|
|
95
91
|
|
|
@@ -105,7 +101,7 @@ export const Arr = {
|
|
|
105
101
|
return move(arr, from, to)
|
|
106
102
|
},
|
|
107
103
|
|
|
108
|
-
clampArrayRange(arr: readonly unknown[], n: number) {
|
|
104
|
+
clampArrayRange(arr: readonly unknown[], n: number): number {
|
|
109
105
|
return clampArrayRange(arr, n)
|
|
110
106
|
},
|
|
111
107
|
|
|
@@ -146,4 +142,4 @@ export const Arr = {
|
|
|
146
142
|
},
|
|
147
143
|
}
|
|
148
144
|
|
|
149
|
-
export const arr = Arr
|
|
145
|
+
export const arr: typeof Arr = Arr
|
package/src/math.ts
CHANGED
|
@@ -34,7 +34,8 @@ export function avg(arr: number[]): number {
|
|
|
34
34
|
* ```
|
|
35
35
|
*/
|
|
36
36
|
export function median(arr: number[]): number {
|
|
37
|
-
if (arr.length === 0)
|
|
37
|
+
if (arr.length === 0)
|
|
38
|
+
throw new Error('Cannot compute median of an empty array')
|
|
38
39
|
|
|
39
40
|
const sorted = [...arr].sort((a, b) => a - b)
|
|
40
41
|
|
|
@@ -42,7 +43,8 @@ export function median(arr: number[]): number {
|
|
|
42
43
|
|
|
43
44
|
let medianValue: number
|
|
44
45
|
|
|
45
|
-
if (sorted.length % 2 !== 0)
|
|
46
|
+
if (sorted.length % 2 !== 0)
|
|
47
|
+
medianValue = sorted[mid] as number
|
|
46
48
|
else medianValue = ((sorted[mid] as number) + (sorted[mid - 1] as number)) / 2 // or (sorted[mid - 1] + sorted[mid]) / 2
|
|
47
49
|
|
|
48
50
|
return medianValue
|
|
@@ -62,7 +64,7 @@ export function median(arr: number[]): number {
|
|
|
62
64
|
* ```
|
|
63
65
|
*/
|
|
64
66
|
export function mode(arr: number[]): number {
|
|
65
|
-
return arr.sort((a, b) => arr.filter(
|
|
67
|
+
return arr.sort((a, b) => arr.filter(v => v === a).length - arr.filter(v => v === b).length).pop() as number
|
|
66
68
|
}
|
|
67
69
|
|
|
68
70
|
/**
|
|
@@ -146,7 +148,7 @@ export function range(array: readonly number[]): number {
|
|
|
146
148
|
*/
|
|
147
149
|
export function variance(array: number[]): number {
|
|
148
150
|
const mean = average(array)
|
|
149
|
-
return average(array.map(
|
|
151
|
+
return average(array.map(num => (num - mean) ** 2))
|
|
150
152
|
}
|
|
151
153
|
|
|
152
154
|
/**
|
|
@@ -193,7 +195,15 @@ export function zScore(array: number[], num: number): number {
|
|
|
193
195
|
* @see https://en.wikipedia.org/wiki/Percentile
|
|
194
196
|
*/
|
|
195
197
|
export function percentile(array: number[], num: number): number {
|
|
196
|
-
|
|
198
|
+
const sorted = [...array].sort((a, b) => a - b)
|
|
199
|
+
const index = (num / 100) * (sorted.length - 1)
|
|
200
|
+
const lower = Math.floor(index)
|
|
201
|
+
const upper = Math.ceil(index)
|
|
202
|
+
const weight = index - lower
|
|
203
|
+
|
|
204
|
+
if (upper === lower)
|
|
205
|
+
return sorted[index] ?? 0
|
|
206
|
+
return (1 - weight) * (sorted[lower] ?? 0) + weight * (sorted[upper] ?? 0)
|
|
197
207
|
}
|
|
198
208
|
|
|
199
209
|
/**
|
|
@@ -225,7 +235,8 @@ export function interquartileRange(array: number[]): number {
|
|
|
225
235
|
* ```
|
|
226
236
|
*/
|
|
227
237
|
export function covariance(array1: number[], array2: number[]): number {
|
|
228
|
-
if (array1.length !== array2.length)
|
|
238
|
+
if (array1.length !== array2.length)
|
|
239
|
+
throw new Error('Arrays must have the same length')
|
|
229
240
|
|
|
230
241
|
const mean1 = average(array1)
|
|
231
242
|
const mean2 = average(array2)
|