4211530769

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/cocopon/tweakpane/commit/<a class=hub.com/cocopon/tweakpane/commit/b20808801048a41255da9c6f3a9b2fa146c00760">b20808801<a href="https://github.com/cocopon/tweakpane/commit/b20808801048a41255da9c6f3a9b2fa146c00760">">Merge </a><a class="double-link" href="https://github.com/cocopon/tweakpane/commit/<a class="double-link" href="https://github.com/cocopon/tweakpane/commit/11383e257fbeed379439ba071a479ce2eff86e55">11383e257</a>">11383e257</a><a href="https://github.com/cocopon/tweakpane/commit/b20808801048a41255da9c6f3a9b2fa146c00760"> into 4f5175b81">4f5175b81</a>

Pull Request Pull Request #487: Unify `addInput()` and `addMonitor()`

Run Details

1232 of 1632 branches covered (75.49%)

Branch coverage included in aggregate %.

37 of 37 new or added lines in 4 files covered. (100.0%)

4478 of 4909 relevant lines covered (91.22%)

714.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.56

/packages/core/src/plugin/pool.ts

import {BindingApi} from '../blade/binding/api/binding';
import {InputBindingApi} from '../blade/binding/api/input-binding';
import {MonitorBindingApi} from '../blade/binding/api/monitor-binding';
import {
        BindingController,
        isBindingController,
} from '../blade/binding/controller/binding';
import {
        InputBindingController,
        isInputBindingController,
} from '../blade/binding/controller/input-binding';
import {
        isMonitorBindingController,
        MonitorBindingController,
} from '../blade/binding/controller/monitor-binding';
import {BladeApi} from '../blade/common/api/blade';
import {BindingParams} from '../blade/common/api/params';
import {BladeController} from '../blade/common/controller/blade';
import {BladePlugin, createBladeController} from '../blade/plugin';
import {BindingTarget} from '../common/binding/target';
import {TpError} from '../common/tp-error';
import {isCompatible} from '../index';
import {
        createInputBindingController,
        InputBindingPlugin,
} from '../input-binding/plugin';
import {isEmpty} from '../misc/type-util';
import {
        createMonitorBindingController,
        MonitorBindingPlugin,
} from '../monitor-binding/plugin';
import {TpPlugin} from './plugins';

/**
 * @hidden
 */
export class PluginPool {
        private readonly pluginsMap_: {
                blades: BladePlugin<any>[];
                inputs: InputBindingPlugin<any, any, any>[];
                monitors: MonitorBindingPlugin<any, any>[];
        } = {
                blades: [],
                inputs: [],
                monitors: [],
        };

        public getAll(): TpPlugin[] {
                return [
                        ...this.pluginsMap_.blades,
                        ...this.pluginsMap_.inputs,
                        ...this.pluginsMap_.monitors,
                ];
        }

        public register(r: TpPlugin): void {
                if (!isCompatible(r.core)) {
                        throw TpError.notCompatible(r.id);
                }

                if (r.type === 'blade') {
                        this.pluginsMap_.blades.unshift(r);
                } else if (r.type === 'input') {
                        this.pluginsMap_.inputs.unshift(r);
                } else if (r.type === 'monitor') {
                        this.pluginsMap_.monitors.unshift(r);
                }
        }

        private createInput_(
                document: Document,
                target: BindingTarget,
                params: BindingParams,
        ): InputBindingController | null {
                return this.pluginsMap_.inputs.reduce(
                        (result: InputBindingController | null, plugin) =>
                                result ??
                                createInputBindingController(plugin, {
                                        document: document,
                                        target: target,
                                        params: params,
                                        presetKey:
                                                typeof params.presetKey === 'string' ? params.presetKey : undefined,
                                }),
                        null,
                );
        }

        private createMonitor_(
                document: Document,
                target: BindingTarget,
                params: BindingParams,
        ): MonitorBindingController | null {
                return this.pluginsMap_.monitors.reduce(
                        (result: MonitorBindingController | null, plugin) =>
                                result ??
                                createMonitorBindingController(plugin, {
                                        document: document,
                                        params: params,
                                        target: target,
                                }),
                        null,
                );
        }

        public createBinding(
                doc: Document,
                target: BindingTarget,
                params: BindingParams,
        ): BindingController {
                const initialValue = target.read();
                if (isEmpty(initialValue)) {
                        throw new TpError({
                                context: {
                                        key: target.key,
                                },
                                type: 'nomatchingcontroller',
                        });
                }

                const ic = this.createInput_(doc, target, params);
                if (ic) {
                        return ic;
                }

                const mc = this.createMonitor_(doc, target, params);
                if (mc) {
                        return mc as BindingController;
                }

                throw new TpError({
                        context: {
                                key: target.key,
                        },
                        type: 'nomatchingcontroller',
                });
        }

        public createBlade(
                document: Document,
                params: Record<string, unknown>,
        ): BladeController {
                const bc = this.pluginsMap_.blades.reduce(
                        (result: BladeController | null, plugin) =>
                                result ??
                                createBladeController(plugin, {
                                        document: document,
                                        params: params,
                                }),
                        null,
                );
                if (!bc) {
                        throw new TpError({
                                type: 'nomatchingview',
                                context: {
                                        params: params,
                                },
                        });
                }
                return bc;
        }

        public createBladeApi(bc: BladeController): BladeApi {
                if (isBindingController(bc)) {
                        return new BindingApi(bc);
                }

                const api = this.pluginsMap_.blades.reduce(
                        (result: BladeApi | null, plugin) =>
                                result ??
                                plugin.api({
                                        controller: bc,
                                        pool: this,
                                }),
                        null,
                );
                if (!api) {
                        throw TpError.shouldNeverHappen();
                }
                return api;
        }

        private createInputBindingApi_(
                bc: InputBindingController,
        ): InputBindingApi | null {
                return this.pluginsMap_.inputs.reduce(
                        (result: InputBindingApi | null, plugin) => {
                                if (result) {
                                        return result;
                                }
                                return (
                                        plugin.api?.({
                                                controller: bc as InputBindingController,
                                        }) ?? null
                                );
                        },
                        null,
                );
        }

        private createMonitorBindingApi_(
                bc: MonitorBindingController,
        ): MonitorBindingApi {
                const api = this.pluginsMap_.monitors.reduce(
                        (result: MonitorBindingApi | null, plugin) => {
                                if (result) {
                                        return result;
                                }
                                return (
                                        plugin.api?.({
                                                controller: bc as MonitorBindingController,
                                        }) ?? null
                                );
                        },
                        null,
                );
                return api ?? new BindingApi(bc);
        }

        public createBindingApi(bc: BindingController): BindingApi {
                if (isInputBindingController(bc)) {
                        const api = this.createInputBindingApi_(bc);
                        if (api) {
                                return api;
                        }
                }
                if (isMonitorBindingController(bc)) {
                        const api = this.createMonitorBindingApi_(bc);
                        if (api) {
                                return api as BindingApi;
                        }
                }
                return new BindingApi(bc);
        }
}

1	import {BindingApi} from '../blade/binding/api/binding';	1✔
2	import {InputBindingApi} from '../blade/binding/api/input-binding';
3	import {MonitorBindingApi} from '../blade/binding/api/monitor-binding';
4	import {	1✔
5	BindingController,
6	isBindingController,
7	} from '../blade/binding/controller/binding';
8	import {	1✔
9	InputBindingController,
10	isInputBindingController,
11	} from '../blade/binding/controller/input-binding';
12	import {	1✔
13	isMonitorBindingController,
14	MonitorBindingController,
15	} from '../blade/binding/controller/monitor-binding';
16	import {BladeApi} from '../blade/common/api/blade';
17	import {BindingParams} from '../blade/common/api/params';
18	import {BladeController} from '../blade/common/controller/blade';
19	import {BladePlugin, createBladeController} from '../blade/plugin';	1✔
20	import {BindingTarget} from '../common/binding/target';
21	import {TpError} from '../common/tp-error';	1✔
22	import {isCompatible} from '../index';	1✔
23	import {	1✔
24	createInputBindingController,
25	InputBindingPlugin,
26	} from '../input-binding/plugin';
27	import {isEmpty} from '../misc/type-util';	1✔
28	import {	1✔
29	createMonitorBindingController,
30	MonitorBindingPlugin,
31	} from '../monitor-binding/plugin';
32	import {TpPlugin} from './plugins';
33
34	/**
35	* @hidden
36	*/
37	export class PluginPool {	1✔
38	private readonly pluginsMap_: {	70✔
39	blades: BladePlugin<any>[];
40	inputs: InputBindingPlugin<any, any, any>[];
41	monitors: MonitorBindingPlugin<any, any>[];
42	} = {
43	blades: [],
44	inputs: [],
45	monitors: [],
46	};
47
48	public getAll(): TpPlugin[] {	1✔
49	return [	×
50	...this.pluginsMap_.blades,
51	...this.pluginsMap_.inputs,
52	...this.pluginsMap_.monitors,
53	];
54	}
55
56	public register(r: TpPlugin): void {	1✔
57	if (!isCompatible(r.core)) {	1,124!
58	throw TpError.notCompatible(r.id);	×
59	}
60
61	if (r.type === 'blade') {	1,124✔
62	this.pluginsMap_.blades.unshift(r);	284✔
63	} else if (r.type === 'input') {	840✔
64	this.pluginsMap_.inputs.unshift(r);	630✔
65	} else if (r.type === 'monitor') {	210!
66	this.pluginsMap_.monitors.unshift(r);	210✔
67	}
68	}
69
70	private createInput_(	1✔
71	document: Document,
72	target: BindingTarget,
73	params: BindingParams,
74	): InputBindingController \| null {
75	return this.pluginsMap_.inputs.reduce(	29✔
76	(result: InputBindingController \| null, plugin) =>
77	result ??	261✔
78	createInputBindingController(plugin, {
79	document: document,
80	target: target,
81	params: params,
82	presetKey:
83	typeof params.presetKey === 'string' ? params.presetKey : undefined,	143!
84	}),
85	null,
86	);
87	}
88
89	private createMonitor_(	1✔
90	document: Document,
91	target: BindingTarget,
92	params: BindingParams,
93	): MonitorBindingController \| null {
94	return this.pluginsMap_.monitors.reduce(	2✔
95	(result: MonitorBindingController \| null, plugin) =>
96	result ??	6✔
97	createMonitorBindingController(plugin, {
98	document: document,
99	params: params,
100	target: target,
101	}),
102	null,
103	);
104	}
105
106	public createBinding(	1✔
107	doc: Document,
108	target: BindingTarget,
109	params: BindingParams,
110	): BindingController {
111	const initialValue = target.read();	29✔
112	if (isEmpty(initialValue)) {	29!
113	throw new TpError({	×
114	context: {
115	key: target.key,
116	},
117	type: 'nomatchingcontroller',
118	});
119	}
120
121	const ic = this.createInput_(doc, target, params);	29✔
122	if (ic) {	29✔
123	return ic;	27✔
124	}
125
126	const mc = this.createMonitor_(doc, target, params);	2✔
127	if (mc) {	2!
128	return mc as BindingController;	2✔
129	}
130
131	throw new TpError({	×
132	context: {
133	key: target.key,
134	},
135	type: 'nomatchingcontroller',
136	});
137	}
138
139	public createBlade(	1✔
140	document: Document,
141	params: Record<string, unknown>,
142	): BladeController {
143	const bc = this.pluginsMap_.blades.reduce(	42✔
144	(result: BladeController \| null, plugin) =>
145	result ??	169✔
146	createBladeController(plugin, {
147	document: document,
148	params: params,
149	}),
150	null,
151	);
152	if (!bc) {	42!
153	throw new TpError({	×
154	type: 'nomatchingview',
155	context: {
156	params: params,
157	},
158	});
159	}
160	return bc;	42✔
161	}
162
163	public createBladeApi(bc: BladeController): BladeApi {	169✔
164	if (isBindingController(bc)) {	169✔
165	return new BindingApi(bc);	35✔
166	}
167
168	const api = this.pluginsMap_.blades.reduce(	134✔
169	(result: BladeApi \| null, plugin) =>
170	result ??	539✔
171	plugin.api({
172	controller: bc,
173	pool: this,
174	}),
175	null,
176	);
177	if (!api) {	134!
178	throw TpError.shouldNeverHappen();	×
179	}
180	return api;	134✔
181	}
182
183	private createInputBindingApi_(	1✔
184	bc: InputBindingController,
185	): InputBindingApi \| null {
186	return this.pluginsMap_.inputs.reduce(	27✔
187	(result: InputBindingApi \| null, plugin) => {
188	if (result) {	243!
189	return result;	×
190	}
191	return (	243✔
192	plugin.api?.({	1,377!
193	controller: bc as InputBindingController,
194	}) ?? null
195	);
196	},
197	null,
198	);
199	}
200
201	private createMonitorBindingApi_(	1✔
202	bc: MonitorBindingController,
203	): MonitorBindingApi {
204	const api = this.pluginsMap_.monitors.reduce(	2✔
205	(result: MonitorBindingApi \| null, plugin) => {
206	if (result) {	6!
207	return result;	×
208	}
209	return (	6✔
210	plugin.api?.({	34!
211	controller: bc as MonitorBindingController,
212	}) ?? null
213	);
214	},
215	null,
216	);
217	return api ?? new BindingApi(bc);	2!
218	}
219
220	public createBindingApi(bc: BindingController): BindingApi {	1✔
221	if (isInputBindingController(bc)) {	29✔
222	const api = this.createInputBindingApi_(bc);	27✔
223	if (api) {	27!
224	return api;	×
225	}
226	}
227	if (isMonitorBindingController(bc)) {	29✔
228	const api = this.createMonitorBindingApi_(bc);	2✔
229	if (api) {	2!
230	return api as BindingApi;	2✔
231	}
232	}
233	return new BindingApi(bc);	27✔
234	}
235	}	1✔

cocopon / tweakpane / 4211530769

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous