4104049219

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/cocopon/tweakpane/commit/<a class=hub.com/cocopon/tweakpane/commit/614c164931cc4f51c114c1f8dd7a48a42fb431b6">614c16493<a href="https://github.com/cocopon/tweakpane/commit/614c164931cc4f51c114c1f8dd7a48a42fb431b6">">Merge </a><a class="double-link" href="https://github.com/cocopon/tweakpane/commit/<a class="double-link" href="https://github.com/cocopon/tweakpane/commit/fd17d32e46b5da83d93caf652b54cc65769d5dbe">fd17d32e4</a>">fd17d32e4</a><a href="https://github.com/cocopon/tweakpane/commit/614c164931cc4f51c114c1f8dd7a48a42fb431b6"> into 79acb47f4">79acb47f4</a>

Pull Request Pull Request #475: Provide specified monitor binding APIs

Run Details

1225 of 1626 branches covered (75.34%)

Branch coverage included in aggregate %.

23 of 23 new or added lines in 5 files covered. (100.0%)

4302 of 4735 relevant lines covered (90.86%)

740.93 hits per line

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

81.25

/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 {isBindingController} from '../blade/binding/controller/binding';
import {InputBindingController} from '../blade/binding/controller/input-binding';
import {MonitorBindingController} from '../blade/binding/controller/monitor-binding';
import {BladeApi} from '../blade/common/api/blade';
import {InputParams, MonitorParams} from '../blade/common/api/params';
import {BladeController} from '../blade/common/controller/blade';
import {BladePlugin, createBladeController} from '../blade/plugin';
import {RackApi} from '../blade/rack/api/rack';
import {RackController} from '../blade/rack/controller/rack';
import {BindingTarget} from '../common/binding/target';
import {TpError} from '../common/tp-error';
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 (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);
                }
        }

        public createInput(
                document: Document,
                target: BindingTarget,
                params: InputParams,
        ): InputBindingController<unknown> {
                const initialValue = target.read();

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

                const bc = this.pluginsMap_.inputs.reduce(
                        (result: InputBindingController<unknown> | null, plugin) =>
                                result ??
                                createInputBindingController(plugin, {
                                        document: document,
                                        target: target,
                                        params: params,
                                        presetKey: params.presetKey,
                                }),
                        null,
                );
                if (bc) {
                        return bc;
                }

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

        public createMonitor(
                document: Document,
                target: BindingTarget,
                params: MonitorParams,
        ): MonitorBindingController<unknown> {
                const bc = this.pluginsMap_.monitors.reduce(
                        (result: MonitorBindingController<unknown> | null, plugin) =>
                                result ??
                                createMonitorBindingController(plugin, {
                                        document: document,
                                        params: params,
                                        target: target,
                                }),
                        null,
                );
                if (bc) {
                        return bc;
                }

                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);
                }
                if (bc instanceof RackController) {
                        return new RackApi(bc, this);
                }

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

        public createInputBindingApi<In, Ex>(
                bc: InputBindingController<In>,
        ): InputBindingApi<In, Ex> {
                const api = this.pluginsMap_.inputs.reduce(
                        (result: InputBindingApi<In, Ex> | null, plugin) => {
                                if (result) {
                                        return result;
                                }
                                return (
                                        plugin.api?.({
                                                controller: bc as InputBindingController<unknown>,
                                        }) ?? null
                                );
                        },
                        null,
                );
                return api ?? new BindingApi(bc);
        }

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

cocopon / tweakpane / 4104049219

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