@esportsplus/reactivity 0.2.4 → 0.2.6
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/build/reactive/array.d.ts +165 -13
- package/build/reactive/array.js +12 -4
- package/package.json +1 -1
- package/src/reactive/array.ts +16 -5
|
@@ -1,8 +1,6 @@
|
|
|
1
1
|
import { Infer, Prettify } from '../types';
|
|
2
2
|
import { Listener, Options, ReactiveObject, Signal } from '../types';
|
|
3
|
-
type API<T> = Prettify<
|
|
4
|
-
[index: number]: Infer<T>;
|
|
5
|
-
} & ReturnType<typeof methods<T>>>;
|
|
3
|
+
type API<T> = Prettify<Infer<T>[] & ReturnType<typeof methods<T>>>;
|
|
6
4
|
type Events<T> = {
|
|
7
5
|
pop: {
|
|
8
6
|
item: Item<T>;
|
|
@@ -56,21 +54,175 @@ declare function methods<T>(a: ReactiveArray<T>): Prettify<{
|
|
|
56
54
|
} & Pick<typeof a, 'at' | 'dispatch' | 'dispose' | 'map' | 'on' | 'once' | 'pop' | 'push' | 'reverse' | 'shift' | 'sort' | 'splice' | 'unshift'>>;
|
|
57
55
|
declare const _default: <T>(input: T[], options?: Options) => {
|
|
58
56
|
[x: number]: Infer<T>;
|
|
59
|
-
readonly constructor: Function;
|
|
60
57
|
length: number;
|
|
58
|
+
toString: () => string;
|
|
59
|
+
toLocaleString: {
|
|
60
|
+
(): string;
|
|
61
|
+
(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
|
|
62
|
+
};
|
|
63
|
+
pop: (() => Infer<T> | undefined) & (() => Item<T> | undefined);
|
|
64
|
+
push: ((...items: Infer<T>[]) => number) & ((...input: T[]) => number);
|
|
65
|
+
concat: {
|
|
66
|
+
(...items: ConcatArray<Infer<T>>[]): Infer<T>[];
|
|
67
|
+
(...items: (Infer<T> | ConcatArray<Infer<T>>)[]): Infer<T>[];
|
|
68
|
+
};
|
|
69
|
+
join: (separator?: string) => string;
|
|
70
|
+
reverse: (() => Infer<T>[]) & (() => ReactiveArray<T>);
|
|
71
|
+
shift: (() => Infer<T> | undefined) & (() => Item<T> | undefined);
|
|
72
|
+
slice: (start?: number, end?: number) => Infer<T>[];
|
|
73
|
+
sort: ((compareFn?: ((a: Infer<T>, b: Infer<T>) => number) | undefined) => Infer<T>[] & {
|
|
74
|
+
readonly constructor: Function;
|
|
75
|
+
length: number;
|
|
76
|
+
dispatch: <E extends keyof Events<T>>(event: E, data?: Events<T>[E] | undefined) => void;
|
|
77
|
+
dispose: () => void;
|
|
78
|
+
on: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
79
|
+
once: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
80
|
+
at: (i: number) => any;
|
|
81
|
+
map: <U>(fn: (this: any, value: T, i: number) => U, i?: number, n?: number) => U[];
|
|
82
|
+
pop: () => Item<T> | undefined;
|
|
83
|
+
push: (...input: T[]) => number;
|
|
84
|
+
reverse: () => ReactiveArray<T>;
|
|
85
|
+
shift: () => Item<T> | undefined;
|
|
86
|
+
sort: (fn: (a: T, b: T) => number) => ReactiveArray<T>;
|
|
87
|
+
splice: (start: number, deleteCount?: number, ...input: T[]) => Item<T>[];
|
|
88
|
+
unshift: (...input: T[]) => number;
|
|
89
|
+
}) & ((fn: (a: T, b: T) => number) => ReactiveArray<T>);
|
|
90
|
+
splice: {
|
|
91
|
+
(start: number, deleteCount?: number): Infer<T>[];
|
|
92
|
+
(start: number, deleteCount: number, ...items: Infer<T>[]): Infer<T>[];
|
|
93
|
+
} & ((start: number, deleteCount?: number, ...input: T[]) => Item<T>[]);
|
|
94
|
+
unshift: ((...items: Infer<T>[]) => number) & ((...input: T[]) => number);
|
|
95
|
+
indexOf: (searchElement: Infer<T>, fromIndex?: number) => number;
|
|
96
|
+
lastIndexOf: (searchElement: Infer<T>, fromIndex?: number) => number;
|
|
97
|
+
every: {
|
|
98
|
+
<S extends Infer<T>>(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => value is S, thisArg?: any): this is S[];
|
|
99
|
+
(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any): boolean;
|
|
100
|
+
};
|
|
101
|
+
some: (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any) => boolean;
|
|
102
|
+
forEach: (callbackfn: (value: Infer<T>, index: number, array: Infer<T>[]) => void, thisArg?: any) => void;
|
|
103
|
+
map: (<U>(callbackfn: (value: Infer<T>, index: number, array: Infer<T>[]) => U, thisArg?: any) => U[]) & (<U>(fn: (this: any, value: T, i: number) => U, i?: number, n?: number) => U[]);
|
|
104
|
+
filter: {
|
|
105
|
+
<S extends Infer<T>>(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => value is S, thisArg?: any): S[];
|
|
106
|
+
(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any): Infer<T>[];
|
|
107
|
+
};
|
|
108
|
+
reduce: {
|
|
109
|
+
(callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>): Infer<T>;
|
|
110
|
+
(callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>, initialValue: Infer<T>): Infer<T>;
|
|
111
|
+
<U>(callbackfn: (previousValue: U, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => U, initialValue: U): U;
|
|
112
|
+
};
|
|
113
|
+
reduceRight: {
|
|
114
|
+
(callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>): Infer<T>;
|
|
115
|
+
(callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>, initialValue: Infer<T>): Infer<T>;
|
|
116
|
+
<U>(callbackfn: (previousValue: U, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => U, initialValue: U): U;
|
|
117
|
+
};
|
|
118
|
+
find: {
|
|
119
|
+
<S extends Infer<T>>(predicate: (value: Infer<T>, index: number, obj: Infer<T>[]) => value is S, thisArg?: any): S | undefined;
|
|
120
|
+
(predicate: (value: Infer<T>, index: number, obj: Infer<T>[]) => unknown, thisArg?: any): Infer<T> | undefined;
|
|
121
|
+
};
|
|
122
|
+
findIndex: (predicate: (value: Infer<T>, index: number, obj: Infer<T>[]) => unknown, thisArg?: any) => number;
|
|
123
|
+
fill: (value: Infer<T>, start?: number, end?: number) => Infer<T>[] & {
|
|
124
|
+
readonly constructor: Function;
|
|
125
|
+
length: number;
|
|
126
|
+
dispatch: <E extends keyof Events<T>>(event: E, data?: Events<T>[E] | undefined) => void;
|
|
127
|
+
dispose: () => void;
|
|
128
|
+
on: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
129
|
+
once: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
130
|
+
at: (i: number) => any;
|
|
131
|
+
map: <U>(fn: (this: any, value: T, i: number) => U, i?: number, n?: number) => U[];
|
|
132
|
+
pop: () => Item<T> | undefined;
|
|
133
|
+
push: (...input: T[]) => number;
|
|
134
|
+
reverse: () => ReactiveArray<T>;
|
|
135
|
+
shift: () => Item<T> | undefined;
|
|
136
|
+
sort: (fn: (a: T, b: T) => number) => ReactiveArray<T>;
|
|
137
|
+
splice: (start: number, deleteCount?: number, ...input: T[]) => Item<T>[];
|
|
138
|
+
unshift: (...input: T[]) => number;
|
|
139
|
+
};
|
|
140
|
+
copyWithin: (target: number, start: number, end?: number) => Infer<T>[] & {
|
|
141
|
+
readonly constructor: Function;
|
|
142
|
+
length: number;
|
|
143
|
+
dispatch: <E extends keyof Events<T>>(event: E, data?: Events<T>[E] | undefined) => void;
|
|
144
|
+
dispose: () => void;
|
|
145
|
+
on: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
146
|
+
once: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
147
|
+
at: (i: number) => any;
|
|
148
|
+
map: <U>(fn: (this: any, value: T, i: number) => U, i?: number, n?: number) => U[];
|
|
149
|
+
pop: () => Item<T> | undefined;
|
|
150
|
+
push: (...input: T[]) => number;
|
|
151
|
+
reverse: () => ReactiveArray<T>;
|
|
152
|
+
shift: () => Item<T> | undefined;
|
|
153
|
+
sort: (fn: (a: T, b: T) => number) => ReactiveArray<T>;
|
|
154
|
+
splice: (start: number, deleteCount?: number, ...input: T[]) => Item<T>[];
|
|
155
|
+
unshift: (...input: T[]) => number;
|
|
156
|
+
};
|
|
157
|
+
entries: () => IterableIterator<[number, Infer<T>]>;
|
|
158
|
+
keys: () => IterableIterator<number>;
|
|
159
|
+
values: () => IterableIterator<Infer<T>>;
|
|
160
|
+
includes: (searchElement: Infer<T>, fromIndex?: number) => boolean;
|
|
161
|
+
flatMap: <U, This = undefined>(callback: (this: This, value: Infer<T>, index: number, array: Infer<T>[]) => U | ReadonlyArray<U>, thisArg?: This | undefined) => U[];
|
|
162
|
+
flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
|
|
163
|
+
at: ((index: number) => Infer<T> | undefined) & ((i: number) => any);
|
|
164
|
+
findLast: {
|
|
165
|
+
<S extends Infer<T>>(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => value is S, thisArg?: any): S | undefined;
|
|
166
|
+
(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any): Infer<T> | undefined;
|
|
167
|
+
};
|
|
168
|
+
findLastIndex: (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any) => number;
|
|
169
|
+
toReversed: () => Infer<T>[];
|
|
170
|
+
toSorted: (compareFn?: ((a: Infer<T>, b: Infer<T>) => number) | undefined) => Infer<T>[];
|
|
171
|
+
toSpliced: {
|
|
172
|
+
(start: number, deleteCount: number, ...items: Infer<T>[]): Infer<T>[];
|
|
173
|
+
(start: number, deleteCount?: number): Infer<T>[];
|
|
174
|
+
};
|
|
175
|
+
with: (index: number, value: Infer<T>) => Infer<T>[];
|
|
176
|
+
[Symbol.iterator]: () => IterableIterator<Infer<T>>;
|
|
177
|
+
readonly [Symbol.unscopables]: {
|
|
178
|
+
[x: number]: boolean | undefined;
|
|
179
|
+
length?: boolean | undefined;
|
|
180
|
+
toString?: boolean | undefined;
|
|
181
|
+
toLocaleString?: boolean | undefined;
|
|
182
|
+
pop?: boolean | undefined;
|
|
183
|
+
push?: boolean | undefined;
|
|
184
|
+
concat?: boolean | undefined;
|
|
185
|
+
join?: boolean | undefined;
|
|
186
|
+
reverse?: boolean | undefined;
|
|
187
|
+
shift?: boolean | undefined;
|
|
188
|
+
slice?: boolean | undefined;
|
|
189
|
+
sort?: boolean | undefined;
|
|
190
|
+
splice?: boolean | undefined;
|
|
191
|
+
unshift?: boolean | undefined;
|
|
192
|
+
indexOf?: boolean | undefined;
|
|
193
|
+
lastIndexOf?: boolean | undefined;
|
|
194
|
+
every?: boolean | undefined;
|
|
195
|
+
some?: boolean | undefined;
|
|
196
|
+
forEach?: boolean | undefined;
|
|
197
|
+
map?: boolean | undefined;
|
|
198
|
+
filter?: boolean | undefined;
|
|
199
|
+
reduce?: boolean | undefined;
|
|
200
|
+
reduceRight?: boolean | undefined;
|
|
201
|
+
find?: boolean | undefined;
|
|
202
|
+
findIndex?: boolean | undefined;
|
|
203
|
+
fill?: boolean | undefined;
|
|
204
|
+
copyWithin?: boolean | undefined;
|
|
205
|
+
entries?: boolean | undefined;
|
|
206
|
+
keys?: boolean | undefined;
|
|
207
|
+
values?: boolean | undefined;
|
|
208
|
+
includes?: boolean | undefined;
|
|
209
|
+
flatMap?: boolean | undefined;
|
|
210
|
+
flat?: boolean | undefined;
|
|
211
|
+
at?: boolean | undefined;
|
|
212
|
+
findLast?: boolean | undefined;
|
|
213
|
+
findLastIndex?: boolean | undefined;
|
|
214
|
+
toReversed?: boolean | undefined;
|
|
215
|
+
toSorted?: boolean | undefined;
|
|
216
|
+
toSpliced?: boolean | undefined;
|
|
217
|
+
with?: boolean | undefined;
|
|
218
|
+
[Symbol.iterator]?: boolean | undefined;
|
|
219
|
+
readonly [Symbol.unscopables]?: boolean | undefined;
|
|
220
|
+
};
|
|
221
|
+
readonly constructor: Function;
|
|
61
222
|
dispatch: <E extends keyof Events<T>>(event: E, data?: Events<T>[E] | undefined) => void;
|
|
62
223
|
dispose: () => void;
|
|
63
224
|
on: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
64
225
|
once: <E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) => void;
|
|
65
|
-
at: (i: number) => any;
|
|
66
|
-
map: <U>(fn: (this: any, value: T, i: number) => U, i?: number, n?: number) => U[];
|
|
67
|
-
pop: () => Item<T> | undefined;
|
|
68
|
-
push: (...input: T[]) => number;
|
|
69
|
-
reverse: () => ReactiveArray<T>;
|
|
70
|
-
shift: () => Item<T> | undefined;
|
|
71
|
-
sort: (fn: (a: T, b: T) => number) => ReactiveArray<T>;
|
|
72
|
-
splice: (start: number, deleteCount?: number, ...input: T[]) => Item<T>[];
|
|
73
|
-
unshift: (...input: T[]) => number;
|
|
74
226
|
};
|
|
75
227
|
export default _default;
|
|
76
228
|
export { API as ReactiveArray };
|
package/build/reactive/array.js
CHANGED
|
@@ -6,7 +6,10 @@ class ReactiveArray extends Array {
|
|
|
6
6
|
proxy;
|
|
7
7
|
signal;
|
|
8
8
|
constructor(data, proxy, options = {}) {
|
|
9
|
-
super(
|
|
9
|
+
super();
|
|
10
|
+
for (let i = 0, n = data.length; i < n; i++) {
|
|
11
|
+
super.push(data[i]);
|
|
12
|
+
}
|
|
10
13
|
this.options = options;
|
|
11
14
|
this.proxy = proxy;
|
|
12
15
|
this.signal = signal(false);
|
|
@@ -158,11 +161,16 @@ export default (input, options = {}) => {
|
|
|
158
161
|
set(_, key, value) {
|
|
159
162
|
if (isNumber(key)) {
|
|
160
163
|
let host = a[key];
|
|
161
|
-
if (
|
|
164
|
+
if (host === undefined) {
|
|
165
|
+
a[key] = factory([value], options)[0];
|
|
166
|
+
}
|
|
167
|
+
else if (isInstanceOf(host, Reactive)) {
|
|
162
168
|
host.set(value);
|
|
163
|
-
return true;
|
|
164
169
|
}
|
|
165
|
-
|
|
170
|
+
else {
|
|
171
|
+
return false;
|
|
172
|
+
}
|
|
173
|
+
return true;
|
|
166
174
|
}
|
|
167
175
|
return a[key] = value;
|
|
168
176
|
}
|
package/package.json
CHANGED
package/src/reactive/array.ts
CHANGED
|
@@ -5,7 +5,7 @@ import { Listener, Options, ReactiveObject, Signal } from '~/types';
|
|
|
5
5
|
import object from './object';
|
|
6
6
|
|
|
7
7
|
|
|
8
|
-
type API<T> = Prettify<
|
|
8
|
+
type API<T> = Prettify< Infer<T>[] & ReturnType<typeof methods<T>> >;
|
|
9
9
|
|
|
10
10
|
type Events<T> = {
|
|
11
11
|
pop: {
|
|
@@ -46,7 +46,13 @@ class ReactiveArray<T> extends Array<Item<T>> {
|
|
|
46
46
|
|
|
47
47
|
|
|
48
48
|
constructor(data: Item<T>[], proxy: API<T>, options: Options = {}) {
|
|
49
|
-
super(
|
|
49
|
+
super();
|
|
50
|
+
|
|
51
|
+
// Only method I could use to prevent TS and runtime JS errors
|
|
52
|
+
for (let i = 0, n = data.length; i < n; i++) {
|
|
53
|
+
super.push(data[i]);
|
|
54
|
+
}
|
|
55
|
+
|
|
50
56
|
this.options = options;
|
|
51
57
|
this.proxy = proxy;
|
|
52
58
|
this.signal = signal(false);
|
|
@@ -283,12 +289,17 @@ export default <T>(input: T[], options: Options = {}) => {
|
|
|
283
289
|
if (isNumber(key)) {
|
|
284
290
|
let host = a[key];
|
|
285
291
|
|
|
286
|
-
if (
|
|
292
|
+
if (host === undefined) {
|
|
293
|
+
a[key] = factory([value] as T[], options)[0];
|
|
294
|
+
}
|
|
295
|
+
else if (isInstanceOf(host, Reactive)) {
|
|
287
296
|
host.set(value);
|
|
288
|
-
|
|
297
|
+
}
|
|
298
|
+
else {
|
|
299
|
+
return false;
|
|
289
300
|
}
|
|
290
301
|
|
|
291
|
-
return
|
|
302
|
+
return true;
|
|
292
303
|
}
|
|
293
304
|
|
|
294
305
|
return a[key] = value;
|