29091048042

Committed 10 Jul 2026 11:57AM UTC coverage: 73.586% (+0.8%) from 72.802%

Build # 29091048042

Build Type

Pull #323

github

Committed by

web-flow

Commit Message

Merge a7a0b7642 into 7aa945dd8

Pull Request Pull Request #323: Add component library postfix to `library` statements

Coverage Stats

3842 of 5489 branches covered (69.99%)

Branch coverage included in aggregate %.

66 of 102 new or added lines in 2 files covered. (64.71%)

1442 existing lines in 106 files now uncovered.

6296 of 8288 relevant lines covered (75.97%)

45.79 hits per line

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

82.5

/src/debugProtocol/PluginInterface.ts

// inspiration: https://github.com/andywer/typed-emitter/blob/master/index.d.ts
export type Arguments<T> = [T] extends [(...args: infer U) => any]
    ? U
    : [T] extends [void] ? [] : [T];

export default class PluginInterface<TPlugin> {
    constructor(
        plugins = [] as TPlugin[]
    ) {
        for (const plugin of plugins ?? []) {
            this.add(plugin);
        }
    }

    private plugins: Array<PluginContainer<TPlugin>> = [];

    /**
     * Call `event` on plugins
     */
    public async emit<K extends keyof TPlugin & string>(eventName: K, event: Arguments<TPlugin[K]>[0]) {
        for (let { plugin } of this.plugins) {
            if ((plugin as any)[eventName]) {
                await Promise.resolve((plugin as any)[eventName](event));
            }
        }
        return event;
    }

    /**
     * Add a plugin to the end of the list of plugins
     * @param plugin the plugin
     * @param priority the priority for the plugin. Lower number means higher priority. (ex: 1 executes before 5)
     */
    public add<T extends TPlugin = TPlugin>(plugin: T, priority = 1) {
        const container = {
            plugin: plugin,
            priority: priority
        };
        this.plugins.push(container);

        //sort the plugins by priority
        this.plugins.sort((a, b) => {
            return a.priority - b.priority;
        });

        return plugin;
    }

    /**
     * Adds a temporary plugin with a single event hook, and resolve a promise with the event from the next occurance of that event.
     * Once the event fires for the first time, the plugin is unregistered.
     * @param eventName the name of the event to subscribe to
     * @param priority the priority for this event. Lower number means higher priority. (ex: 1 executes before 5)
     */
    public once<TEventType>(eventName: keyof TPlugin, priority = 1): Promise<TEventType> {
        return this.onceIf(eventName, () => true, priority);
    }

    /**
     * Adds a temporary plugin with a single event hook, and resolve a promise with the event from the next occurance of that event.
     * Once the event fires for the first time and the matcher evaluates to true, the plugin is unregistered.
     * @param eventName the name of the event to subscribe to
     * @param matcher a function to call that, when true, will deregister this hander and return the event
     * @param priority the priority for this event. Lower number means higher priority. (ex: 1 executes before 5)
     */
    public onceIf<TEventType>(eventName: keyof TPlugin, matcher: (TEventType) => boolean, priority = 1): Promise<TEventType> {
        return new Promise((resolve) => {
            const tempPlugin = {} as any;
            tempPlugin[eventName] = (event) => {
                if (matcher(event)) {
                    //remove the temp plugin
                    this.remove(tempPlugin);
                    //resolve the promise with this event
                    resolve(event);
                }
            };
            this.add(tempPlugin, priority);
        }) as any;
    }

    /**
     * Remove the specified plugin
     */
    public remove<T extends TPlugin = TPlugin>(plugin: T) {
        for (let i = this.plugins.length - 1; i >= 0; i--) {
            if (this.plugins[i].plugin === plugin) {
                this.plugins.splice(i, 1);
            }
        }
    }

    /**
     * Remove all plugins
     */
    public clear() {
        this.plugins = [];
    }
}

interface PluginContainer<TPlugin> {
    plugin: TPlugin;
    priority: number;
}

1	// inspiration: https://github.com/andywer/typed-emitter/blob/master/index.d.ts
2	export type Arguments<T> = [T] extends [(...args: infer U) => any]	2✔
3	? U
4	: [T] extends [void] ? [] : [T];	157✔
5		157✔
6	export default class PluginInterface<TPlugin> {	157!
UNCOV 7	constructor(	×
8	plugins = [] as TPlugin[]
9	) {
10	for (const plugin of plugins ?? []) {
11	this.add(plugin);
12	}
13	}
14		1,900✔
15	private plugins: Array<PluginContainer<TPlugin>> = [];	1,913✔
16		557✔
17	/**
18	* Call `event` on plugins
19	*/	1,899✔
20	public async emit<K extends keyof TPlugin & string>(eventName: K, event: Arguments<TPlugin[K]>[0]) {
21	for (let { plugin } of this.plugins) {
22	if ((plugin as any)[eventName]) {
23	await Promise.resolve((plugin as any)[eventName](event));
24	}
25	}
26	return event;	81✔
27	}	158✔
28
29	/**
30	* Add a plugin to the end of the list of plugins
31	* @param plugin the plugin	158✔
32	* @param priority the priority for the plugin. Lower number means higher priority. (ex: 1 executes before 5)
33	*/	158✔
34	public add<T extends TPlugin = TPlugin>(plugin: T, priority = 1) {	2✔
35	const container = {
36	plugin: plugin,	158✔
37	priority: priority
38	};
39	this.plugins.push(container);
40
41	//sort the plugins by priority
42	this.plugins.sort((a, b) => {
43	return a.priority - b.priority;
44	});	×
UNCOV 45		×
46	return plugin;
47	}
48
49	/**
50	* Adds a temporary plugin with a single event hook, and resolve a promise with the event from the next occurance of that event.
51	* Once the event fires for the first time, the plugin is unregistered.
52	* @param eventName the name of the event to subscribe to
53	* @param priority the priority for this event. Lower number means higher priority. (ex: 1 executes before 5)
54	*/	×
55	public once<TEventType>(eventName: keyof TPlugin, priority = 1): Promise<TEventType> {	1✔
56	return this.onceIf(eventName, () => true, priority);	1✔
57	}	1✔
58		1!
59	/**
60	* Adds a temporary plugin with a single event hook, and resolve a promise with the event from the next occurance of that event.	1✔
61	* Once the event fires for the first time and the matcher evaluates to true, the plugin is unregistered.
62	* @param eventName the name of the event to subscribe to	1✔
63	* @param matcher a function to call that, when true, will deregister this hander and return the event
64	* @param priority the priority for this event. Lower number means higher priority. (ex: 1 executes before 5)
65	*/	1✔
66	public onceIf<TEventType>(eventName: keyof TPlugin, matcher: (TEventType) => boolean, priority = 1): Promise<TEventType> {
67	return new Promise((resolve) => {
68	const tempPlugin = {} as any;
69	tempPlugin[eventName] = (event) => {
70	if (matcher(event)) {
71	//remove the temp plugin
72	this.remove(tempPlugin);	1✔
73	//resolve the promise with this event	2✔
74	resolve(event);	1✔
75	}
76	};
77	this.add(tempPlugin, priority);
78	}) as any;
79	}
80
81	/**
UNCOV 82	* Remove the specified plugin	×
83	*/
84	public remove<T extends TPlugin = TPlugin>(plugin: T) {
85	for (let i = this.plugins.length - 1; i >= 0; i--) {	2✔
86	if (this.plugins[i].plugin === plugin) {
87	this.plugins.splice(i, 1);
88	}
89	}
90	}
91
92	/**
93	* Remove all plugins
94	*/
95	public clear() {
96	this.plugins = [];
97	}
98	}
99
100	interface PluginContainer<TPlugin> {
101	plugin: TPlugin;
102	priority: number;
103	}

rokucommunity / roku-debug / 29091048042

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