4335284401

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/cocopon/tweakpane/commit/<a class=hub.com/cocopon/tweakpane/commit/1b5ca9a1f3d878308cd67b45332011198c1eb14c">1b5ca9a1f<a href="https://github.com/cocopon/tweakpane/commit/1b5ca9a1f3d878308cd67b45332011198c1eb14c">">Merge </a><a class="double-link" href="https://github.com/cocopon/tweakpane/commit/<a class="double-link" href="https://github.com/cocopon/tweakpane/commit/4fc99fa953cb05ca92fbe73c86b954048d3f3459">4fc99fa95</a>">4fc99fa95</a><a href="https://github.com/cocopon/tweakpane/commit/1b5ca9a1f3d878308cd67b45332011198c1eb14c"> into c69ddc543">c69ddc543</a>

Pull Request Pull Request #507: Refactor rack API

Run Details

1263 of 1679 branches covered (75.22%)

Branch coverage included in aggregate %.

46 of 46 new or added lines in 9 files covered. (100.0%)

4557 of 4987 relevant lines covered (91.38%)

704.91 hits per line

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

83.33

/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 {TpBuffer} from '../common/model/buffered-value';
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 {BladeApiCache} from './blade-api-cache';
import {TpPlugin} from './plugins';

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

        constructor(apiCache: BladeApiCache) {
                this.apiCache_ = apiCache;
        }

        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,
                                }),
                        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;
        }

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

        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 this.apiCache_.add(
                        bc,
                        api ??
                                new BindingApi<
                                        TpBuffer<unknown>,
                                        unknown,
                                        MonitorBindingController<unknown>
                                >(bc),
                ) as MonitorBindingApi;
        }

        public createBindingApi(bc: BindingController): BindingApi {
                if (this.apiCache_.has(bc)) {
                        return this.apiCache_.get(bc) as BindingApi;
                }

                if (isInputBindingController(bc)) {
                        return this.createInputBindingApi_(bc);
                }
                /* istanbul ignore else */
                if (isMonitorBindingController(bc)) {
                        return this.createMonitorBindingApi_(bc) as BindingApi;
                }
                /* istanbul ignore next */
                throw TpError.shouldNeverHappen();
        }

        public createApi(bc: BladeController): BladeApi {
                if (this.apiCache_.has(bc)) {
                        return this.apiCache_.get(bc) as BladeApi;
                }

                if (isBindingController(bc)) {
                        return this.createBindingApi(bc);
                }

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

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

cocopon / tweakpane / 4335284401

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