5a7724a5-9fc5-4784-b65b-7a945923b72b

Build # 5a7724a5-9fc5-4784-b65b-7a945923b72b

Build Type

circleci

Committed by Sebastian Rettig

Commit Message

feat(html export): added JS minification

Pull Request Pull Request #935: feat(html export): added html exporter

Run Details

1164 of 1595 branches covered (72.98%)

Branch coverage included in aggregate %.

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

28 existing lines in 2 files now uncovered.

2928 of 3263 relevant lines covered (89.73%)

6939.87 hits per line

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

59.77

/src/H5PPlayer.ts

import LibraryName from './LibraryName';
import {
    ContentId,
    ContentParameters,
    IAssets,
    IContentMetadata,
    IContentStorage,
    IH5PConfig,
    IInstalledLibrary,
    IIntegration,
    ILibraryName,
    ILibraryStorage,
    IPlayerModel,
    IUrlGenerator,
    ILibraryMetadata,
    IUser
} from './types';
import UrlGenerator from './UrlGenerator';
import Logger from './helpers/Logger';
import { ContentMetadata } from './ContentMetadata';

import defaultTranslation from '../assets/translations/client/en.json';
import playerAssetList from './playerAssetList.json';
import player from './renderers/player';
import H5pError from './helpers/H5pError';
import LibraryManager from './LibraryManager';

const log = new Logger('Player');

export default class H5PPlayer {
    /**
     *
     * @param libraryStorage the storage for libraries (can be read only)
     * @param contentStorage the storage for content (can be read only)
     * @param config the configuration object
     * @param integrationObjectDefaults (optional) the default values to use for the integration object
     * @param globalCustomScripts (optional) references to these scripts will be added when rendering content
     */
    constructor(
        private libraryStorage: ILibraryStorage,
        private contentStorage: IContentStorage,
        private config: IH5PConfig,
        private integrationObjectDefaults?: IIntegration,
        private globalCustomScripts: string[] = [],
        private urlGenerator: IUrlGenerator = new UrlGenerator(config)
    ) {
        log.info('initialize');
        this.renderer = player;
        this.clientTranslation = defaultTranslation;
        this.libraryManager = new LibraryManager(
            libraryStorage,
            urlGenerator.libraryFile
        );
    }
    private clientTranslation: any;
    private libraryManager: LibraryManager;
    private renderer: (model: IPlayerModel) => string | any;

    /**
     * Creates a frame for displaying H5P content. You can customize this frame by calling setRenderer(...).
     * It normally is enough to call this method with the content id. Only call it with parameters and metadata
     * if don't want to use the IContentStorage object passed into the constructor.
     * @param contentId the content id
     * @param parameters (optional) the parameters of a piece of content (=content.json)
     * @param metadata (optional) the metadata of a piece of content (=h5p.json)
     * @returns a HTML string that you can insert into your page
     */
    public async render(
        contentId: ContentId,
        parameters?: ContentParameters,
        metadata?: IContentMetadata,
        user?: IUser
    ): Promise<string | any> {
        log.info(`rendering page for ${contentId}`);

        try {
            if (!parameters) {
                // tslint:disable-next-line: no-parameter-reassignment
                parameters = await this.contentStorage.getParameters(contentId);
            }
        } catch (error) {
            throw new H5pError('h5p-player:content-missing', {}, 404);
        }

        try {
            if (!metadata) {
                // tslint:disable-next-line: no-parameter-reassignment
                metadata = await this.contentStorage.getMetadata(contentId);
            }
        } catch (error) {
            throw new H5pError('h5p-player:content-missing', {}, 404);
        }

        log.debug('Getting list of installed addons.');
        let installedAddons: ILibraryMetadata[] = [];
        if (this.libraryStorage?.listAddons) {
            installedAddons = await this.libraryStorage.listAddons();
        }
        // We remove duplicates from the dependency list by converting it to
        // a set and then back.
        const dependencies = Array.from(
            new Set(
                (metadata.preloadedDependencies || [])
                    .concat(
                        await this.getAddonsByParameters(
                            parameters,
                            installedAddons
                        )
                    )
                    .concat(
                        await this.getAddonsByLibrary(
                            metadata.mainLibrary,
                            installedAddons
                        )
                    )
            )
        );

        // Getting lists of scripts and styles needed for the main library.
        const libraries = await this.getMetadataRecursive(dependencies);
        const assets = this.aggregateAssetsRecursive(dependencies, libraries);

        const mainLibrarySupportsFullscreen = !metadata.mainLibrary
            ? false
            : libraries[
                  LibraryName.toUberName(
                      metadata.preloadedDependencies.find(
                          (dep) => dep.machineName === metadata.mainLibrary
                      )
                  )
              ].fullscreen === 1;

        const model: IPlayerModel = {
            contentId,
            downloadPath: this.getDownloadPath(contentId),
            integration: this.generateIntegration(
                contentId,
                parameters,
                metadata,
                assets,
                mainLibrarySupportsFullscreen
            ),
            scripts: this.listCoreScripts()
                .concat(this.globalCustomScripts)
                .concat(assets.scripts),
            styles: this.listCoreStyles().concat(assets.styles),
            translations: {},
            embedTypes: metadata.embedTypes, // TODO: check if the library supports the embed type!
            user
        };

        return this.renderer(model);
    }

    /**
     * Overrides the default renderer.
     * @param renderer
     */
    public setRenderer(
        renderer: (model: IPlayerModel) => string | any
    ): H5PPlayer {
        log.info('changing renderer');
        this.renderer = renderer;
        return this;
    }

    /**
     *
     * @param dependencies
     * @param libraries
     * @param assets
     * @param loaded
     * @returns aggregated asset lists
     */
    private aggregateAssetsRecursive(
        dependencies: ILibraryName[],
        libraries: { [ubername: string]: IInstalledLibrary },
        assets: IAssets = ({
            scripts: [],
            styles: [],
            translations: []
        } = { scripts: [], styles: [], translations: [] }),
        loaded: { [ubername: string]: boolean } = {}
    ): IAssets {
        log.verbose(
            `loading assets from dependencies: ${dependencies
                .map((dep) => LibraryName.toUberName(dep))
                .join(', ')}`
        );
        dependencies.forEach((dependency) => {
            const key = LibraryName.toUberName(dependency);
            if (key in loaded) return;

            loaded[key] = true;
            const lib = libraries[key];
            if (lib) {
                this.aggregateAssetsRecursive(
                    lib.preloadedDependencies || [],
                    libraries,
                    assets,
                    loaded
                );
                (lib.preloadedCss || []).forEach((asset) =>
                    assets.styles.push(
                        this.urlGenerator.libraryFile(dependency, asset.path)
                    )
                );
                (lib.preloadedJs || []).forEach((script) =>
                    assets.scripts.push(
                        this.urlGenerator.libraryFile(dependency, script.path)
                    )
                );
            }
        });
        return assets;
    }

    /**
     * Scans the parameters for occurances of the regex pattern in any string
     * property.
     * @param parameters the parameters (= content.json)
     * @param regex the regex to look for
     * @returns true if the regex occurs in a string inside the parametres
     */
    private checkIfRegexIsInParameters(
        parameters: any,
        regex: RegExp
    ): boolean {
        const type = typeof parameters;
        if (type === 'string') {
            if (regex.test(parameters)) {
                return true;
            }
        } else if (type === 'object') {
            // tslint:disable-next-line: forin
            for (const property in parameters) {
                const found = this.checkIfRegexIsInParameters(
                    parameters[property],
                    regex
                );
                if (found) {
                    return true;
                }
            }
        }
        return false;
    }

    private generateIntegration(
        contentId: ContentId,
        parameters: ContentParameters,
        metadata: IContentMetadata,
        assets: IAssets,
        supportsFullscreen: boolean
    ): IIntegration {
        // see https://h5p.org/creating-your-own-h5p-plugin
        log.info(`generating integration for ${contentId}`);
        return {
            contents: {
                [`cid-${contentId}`]: {
                    displayOptions: {
                        copy: false,
                        copyright: false,
                        embed: false,
                        export: false,
                        frame: false,
                        icon: false
                    },
                    fullScreen: supportsFullscreen ? '1' : '0',
                    jsonContent: JSON.stringify(parameters),
                    library: ContentMetadata.toUbername(metadata),
                    contentUrl: this.config.contentFilesUrlPlayerOverride?.replace(
                        '{{contentId}}',
                        contentId
                    ),
                    metadata: {
                        license: metadata.license || 'U',
                        title: metadata.title || '',
                        defaultLanguage: metadata.language || 'en'
                    },
                    scripts: this.listCoreScripts()
                        .concat(this.globalCustomScripts)
                        .concat(assets.scripts),
                    styles: this.listCoreStyles().concat(assets.styles)
                }
            },
            core: {
                scripts: this.listCoreScripts().concat(
                    this.globalCustomScripts
                ),
                styles: this.listCoreStyles()
            },
            l10n: {
                H5P: this.clientTranslation
            },
            libraryConfig: this.config.libraryConfig,
            postUserStatistics: false,
            saveFreq: false,
            url: this.config.baseUrl,
            hubIsEnabled: true,
            fullscreenDisabled: this.config.disableFullscreen ? 1 : 0,
            ...this.integrationObjectDefaults
        };
    }

    /**
     * Finds out which adds should be added to the library due to the settings
     * in the global configuration or in the library metadata.
     * @param machineName the machine name of the library to which addons should
     * be added
     * @param installedAddons a list of installed addons on the system
     * @returns the list of addons to install
     */
    private async getAddonsByLibrary(
        machineName: string,
        installedAddons: ILibraryMetadata[]
    ): Promise<ILibraryMetadata[]> {
        const neededAddons: ILibraryMetadata[] = [];
        // add addons that are required by the H5P library metadata extension
        for (const installedAddon of installedAddons) {
            // The property addTo.player.machineNames is a custom
            // h5p-nodejs-library extension.
            if (
                installedAddon.addTo?.player?.machineNames?.includes(
                    machineName
                ) ||
                installedAddon.addTo?.player?.machineNames?.includes('*')
            ) {
                log.debug(
                    `Addon ${LibraryName.toUberName(
                        installedAddon
                    )} will be added to the player.`
                );
                neededAddons.push(installedAddon);
            }
        }

        // add addons that are required by the server configuration
        const configRequestedAddons = [
            ...(this.config.playerAddons?.[machineName] ?? []),
            ...(this.config.playerAddons?.['*'] ?? [])
        ];
        for (const addonMachineName of configRequestedAddons) {
            const installedAddonVersions = await this.libraryManager.listInstalledLibraries(
                [addonMachineName]
            );
            if (
                !neededAddons
                    .map((a) => a.machineName)
                    .includes(addonMachineName) &&
                installedAddonVersions[addonMachineName] !== undefined
            ) {
                log.debug(
                    `Addon ${addonMachineName} will be added to the player.`
                );

                neededAddons.push(
                    installedAddonVersions[addonMachineName].sort()[
                        installedAddonVersions[addonMachineName].length - 1
                    ]
                );
            }
        }

        return neededAddons;
    }

    /**
     * Determines which addons should be used for the parameters. It will scan
     * the parameters for patterns specified by installed addons.
     * @param parameters the parameters to scan
     * @param installedAddons a list of addons installed on the system
     * @returns a list of addons that should be used
     */
    private async getAddonsByParameters(
        parameters: any,
        installedAddons: ILibraryMetadata[]
    ): Promise<ILibraryMetadata[]> {
        log.debug('Checking which of the addons must be used for the content.');
        const addonsToAdd: { [key: string]: ILibraryMetadata } = {};
        for (const installedAddon of installedAddons) {
            if (!installedAddon.addTo?.content?.types) {
                continue;
            }

            for (const types of installedAddon.addTo.content.types) {
                if (types.text) {
                    // The regex pattern in the metadata is specified like this:
                    // /mypattern/ or /mypattern/g
                    // Because of this we must extract the actual pattern and
                    // the flags and pass them to the constructor of RegExp.
                    const matches = /^\/(.+?)\/([gimy]+)?$/.exec(
                        types.text.regex
                    );
                    if (matches.length < 1) {
                        log.error(
                            `The addon ${LibraryName.toUberName(
                                installedAddon
                            )} contains an invalid regexp pattern in the addTo selector: ${
                                types.text.regex
                            }. This will be silently ignored, but the addon will never be used!`
                        );
                        continue;
                    }

                    if (
                        this.checkIfRegexIsInParameters(
                            parameters,
                            new RegExp(matches[1], matches[2])
                        )
                    ) {
                        log.debug(
                            `Adding addon ${LibraryName.toUberName(
                                installedAddon
                            )} to dependencies as the regexp pattern ${
                                types.text.regex
                            } was found in the parameters.`
                        );
                        addonsToAdd[
                            installedAddon.machineName
                        ] = installedAddon;
                    }
                }
            }
        }
        return Object.values(addonsToAdd);
    }

    private getDownloadPath(contentId: ContentId): string {
        return this.urlGenerator.downloadPackage(contentId);
    }

    private async getMetadata(
        machineName: string,
        majorVersion: number,
        minorVersion: number
    ): Promise<IInstalledLibrary> {
        log.verbose(
            `loading library ${machineName}-${majorVersion}.${minorVersion}`
        );
        return this.libraryStorage.getLibrary(
            new LibraryName(machineName, majorVersion, minorVersion)
        );
    }

    /**
     *
     * @param dependencies
     * @param loaded can be left out in initial call
     */
    private async getMetadataRecursive(
        dependencies: ILibraryName[],
        loaded: { [ubername: string]: IInstalledLibrary } = {}
    ): Promise<{ [ubername: string]: IInstalledLibrary }> {
        log.verbose(
            `loading libraries from dependencies: ${dependencies
                .map((dep) => LibraryName.toUberName(dep))
                .join(', ')}`
        );
        await Promise.all(
            dependencies.map(async (dependency) => {
                const name = dependency.machineName;
                const majVer = dependency.majorVersion;
                const minVer = dependency.minorVersion;

                const key = LibraryName.toUberName(dependency);
                if (key in loaded) {
                    return;
                }
                let lib;
                try {
                    lib = await this.getMetadata(name, majVer, minVer);
                } catch {
                    log.info(
                        `Could not find library ${name}-${majVer}.${minVer} in storage. Silently ignoring...`
                    );
                }
                if (lib) {
                    loaded[key] = lib;
                    await this.getMetadataRecursive(
                        lib.preloadedDependencies || [],
                        loaded
                    );
                }
            })
        );
        return loaded;
    }

    private listCoreScripts(): string[] {
        return playerAssetList.scripts.core.map(this.urlGenerator.coreFile);
    }

    private listCoreStyles(): string[] {
        return playerAssetList.styles.core.map(this.urlGenerator.coreFile);
    }
}

1	import LibraryName from './LibraryName';	26✔
2	import {
3	ContentId,
4	ContentParameters,
5	IAssets,
6	IContentMetadata,
7	IContentStorage,
8	IH5PConfig,
9	IInstalledLibrary,
10	IIntegration,
11	ILibraryName,
12	ILibraryStorage,
13	IPlayerModel,
14	IUrlGenerator,
15	ILibraryMetadata,
16	IUser
17	} from './types';
18	import UrlGenerator from './UrlGenerator';	26✔
19	import Logger from './helpers/Logger';	26✔
20	import { ContentMetadata } from './ContentMetadata';	26✔
21
22	import defaultTranslation from '../assets/translations/client/en.json';	26✔
23	import playerAssetList from './playerAssetList.json';	26✔
24	import player from './renderers/player';	26✔
25	import H5pError from './helpers/H5pError';	26✔
26	import LibraryManager from './LibraryManager';	26✔
27
28	const log = new Logger('Player');	26✔
29
30	export default class H5PPlayer {	26✔
31	/**
32	*
33	* @param libraryStorage the storage for libraries (can be read only)
34	* @param contentStorage the storage for content (can be read only)
35	* @param config the configuration object
36	* @param integrationObjectDefaults (optional) the default values to use for the integration object
37	* @param globalCustomScripts (optional) references to these scripts will be added when rendering content
38	*/
39	constructor(
40	private libraryStorage: ILibraryStorage,	12✔
41	private contentStorage: IContentStorage,	12✔
42	private config: IH5PConfig,	12✔
43	private integrationObjectDefaults?: IIntegration,	12✔
44	private globalCustomScripts: string[] = [],	22✔
45	private urlGenerator: IUrlGenerator = new UrlGenerator(config)	24!
46	) {
47	log.info('initialize');	12✔
48	this.renderer = player;	12✔
49	this.clientTranslation = defaultTranslation;	12✔
50	this.libraryManager = new LibraryManager(	12✔
51	libraryStorage,
52	urlGenerator.libraryFile
53	);
54	}
55	private clientTranslation: any;
56	private libraryManager: LibraryManager;
57	private renderer: (model: IPlayerModel) => string \| any;
58
59	/**
60	* Creates a frame for displaying H5P content. You can customize this frame by calling setRenderer(...).
61	* It normally is enough to call this method with the content id. Only call it with parameters and metadata
62	* if don't want to use the IContentStorage object passed into the constructor.
63	* @param contentId the content id
64	* @param parameters (optional) the parameters of a piece of content (=content.json)
65	* @param metadata (optional) the metadata of a piece of content (=h5p.json)
66	* @returns a HTML string that you can insert into your page
67	*/
68	public async render(	26✔
69	contentId: ContentId,
70	parameters?: ContentParameters,
71	metadata?: IContentMetadata,
72	user?: IUser
73	): Promise<string \| any> {
74	log.info(`rendering page for ${contentId}`);	12✔
75
76	try {
77	if (!parameters) {	24!
78	// tslint:disable-next-line: no-parameter-reassignment
79	parameters = await this.contentStorage.getParameters(contentId);	×
80	}
81	} catch (error) {
82	throw new H5pError('h5p-player:content-missing', {}, 404);	×
83	}
84
85	try {
86	if (!metadata) {	24!
87	// tslint:disable-next-line: no-parameter-reassignment
88	metadata = await this.contentStorage.getMetadata(contentId);	×
89	}
90	} catch (error) {
91	throw new H5pError('h5p-player:content-missing', {}, 404);	×
92	}
93
94	log.debug('Getting list of installed addons.');	12✔
95	let installedAddons: ILibraryMetadata[] = [];	12✔
96	if (this.libraryStorage?.listAddons) {	12!
97	installedAddons = await this.libraryStorage.listAddons();	×
98	}
99	// We remove duplicates from the dependency list by converting it to
100	// a set and then back.
101	const dependencies = Array.from(	12✔
102	new Set(	12✔
103	(metadata.preloadedDependencies \|\| [])	12✔
104	.concat(
105	await this.getAddonsByParameters(	12✔
106	parameters,
107	installedAddons
108	)
109	)
110	.concat(
111	await this.getAddonsByLibrary(	12✔
112	metadata.mainLibrary,
113	installedAddons
114	)
115	)
116	)
117	);
118
119	// Getting lists of scripts and styles needed for the main library.
120	const libraries = await this.getMetadataRecursive(dependencies);	12✔
121	const assets = this.aggregateAssetsRecursive(dependencies, libraries);	12✔
122
123	const mainLibrarySupportsFullscreen = !metadata.mainLibrary	12✔
124	? false	12✔
125	: libraries[
126	LibraryName.toUberName(
127	metadata.preloadedDependencies.find(
128	(dep) => dep.machineName === metadata.mainLibrary	8✔
129	)
130	)
131	].fullscreen === 1;
132
133	const model: IPlayerModel = {	12✔
134	contentId,
135	downloadPath: this.getDownloadPath(contentId),
136	integration: this.generateIntegration(
137	contentId,
138	parameters,
139	metadata,
140	assets,
141	mainLibrarySupportsFullscreen
142	),
143	scripts: this.listCoreScripts()
144	.concat(this.globalCustomScripts)
145	.concat(assets.scripts),
146	styles: this.listCoreStyles().concat(assets.styles),
147	translations: {},
148	embedTypes: metadata.embedTypes, // TODO: check if the library supports the embed type!
149	user
150	};
151
152	return this.renderer(model);	12✔
153	}
154
155	/**
156	* Overrides the default renderer.
157	* @param renderer
158	*/
159	public setRenderer(	26✔
160	renderer: (model: IPlayerModel) => string \| any
161	): H5PPlayer {
162	log.info('changing renderer');	10✔
163	this.renderer = renderer;	10✔
164	return this;	10✔
165	}
166
167	/**
168	*
169	* @param dependencies
170	* @param libraries
171	* @param assets
172	* @param loaded
173	* @returns aggregated asset lists
174	*/
175	private aggregateAssetsRecursive(	34✔
176	dependencies: ILibraryName[],
177	libraries: { [ubername: string]: IInstalledLibrary },
178	assets: IAssets = ({	42✔
179	scripts: [],
180	styles: [],
181	translations: []
182	} = { scripts: [], styles: [], translations: [] }),
183	loaded: { [ubername: string]: boolean } = {}	42✔
184	): IAssets {
185	log.verbose(	30✔
186	`loading assets from dependencies: ${dependencies
187	.map((dep) => LibraryName.toUberName(dep))	20✔
188	.join(', ')}`
189	);
190	dependencies.forEach((dependency) => {	30✔
191	const key = LibraryName.toUberName(dependency);	20✔
192	if (key in loaded) return;	20✔
193
194	loaded[key] = true;	18✔
195	const lib = libraries[key];	18✔
196	if (lib) {	18!
197	this.aggregateAssetsRecursive(	18✔
198	lib.preloadedDependencies \|\| [],	28✔
199	libraries,
200	assets,
201	loaded
202	);
203	(lib.preloadedCss \|\| []).forEach((asset) =>	18✔
204	assets.styles.push(	18✔
205	this.urlGenerator.libraryFile(dependency, asset.path)
206	)
207	);
208	(lib.preloadedJs \|\| []).forEach((script) =>	18✔
209	assets.scripts.push(	18✔
210	this.urlGenerator.libraryFile(dependency, script.path)
211	)
212	);
213	}
214	});
215	return assets;	30✔
216	}
217
218	/**
219	* Scans the parameters for occurances of the regex pattern in any string
220	* property.
221	* @param parameters the parameters (= content.json)
222	* @param regex the regex to look for
223	* @returns true if the regex occurs in a string inside the parametres
224	*/
225	private checkIfRegexIsInParameters(	26✔
226	parameters: any,
227	regex: RegExp
228	): boolean {
UNCOV 229	const type = typeof parameters;	×
230	if (type === 'string') {	×
231	if (regex.test(parameters)) {	×
232	return true;	×
233	}
UNCOV 234	} else if (type === 'object') {	×
235	// tslint:disable-next-line: forin
UNCOV 236	for (const property in parameters) {	×
237	const found = this.checkIfRegexIsInParameters(	×
238	parameters[property],
239	regex
240	);
UNCOV 241	if (found) {	×
242	return true;	×
243	}
244	}
245	}
UNCOV 246	return false;	×
247	}
248
249	private generateIntegration(	26✔
250	contentId: ContentId,
251	parameters: ContentParameters,
252	metadata: IContentMetadata,
253	assets: IAssets,
254	supportsFullscreen: boolean
255	): IIntegration {
256	// see https://h5p.org/creating-your-own-h5p-plugin
257	log.info(`generating integration for ${contentId}`);	12✔
258	return {	12✔
259	contents: {
260	[`cid-${contentId}`]: {
261	displayOptions: {
262	copy: false,
263	copyright: false,
264	embed: false,
265	export: false,
266	frame: false,
267	icon: false
268	},
269	fullScreen: supportsFullscreen ? '1' : '0',	12!
270	jsonContent: JSON.stringify(parameters),
271	library: ContentMetadata.toUbername(metadata),
272	contentUrl: this.config.contentFilesUrlPlayerOverride?.replace(	36!
273	'{{contentId}}',
274	contentId
275	),
276	metadata: {
277	license: metadata.license \|\| 'U',	24✔
278	title: metadata.title \|\| '',	24✔
279	defaultLanguage: metadata.language \|\| 'en'	24✔
280	},
281	scripts: this.listCoreScripts()
282	.concat(this.globalCustomScripts)
283	.concat(assets.scripts),
284	styles: this.listCoreStyles().concat(assets.styles)
285	}
286	},
287	core: {
288	scripts: this.listCoreScripts().concat(
289	this.globalCustomScripts
290	),
291	styles: this.listCoreStyles()
292	},
293	l10n: {
294	H5P: this.clientTranslation
295	},
296	libraryConfig: this.config.libraryConfig,
297	postUserStatistics: false,
298	saveFreq: false,
299	url: this.config.baseUrl,
300	hubIsEnabled: true,
301	fullscreenDisabled: this.config.disableFullscreen ? 1 : 0,	12!
302	...this.integrationObjectDefaults
303	};
304	}
305
306	/**
307	* Finds out which adds should be added to the library due to the settings
308	* in the global configuration or in the library metadata.
309	* @param machineName the machine name of the library to which addons should
310	* be added
311	* @param installedAddons a list of installed addons on the system
312	* @returns the list of addons to install
313	*/
314	private async getAddonsByLibrary(	26✔
315	machineName: string,
316	installedAddons: ILibraryMetadata[]
317	): Promise<ILibraryMetadata[]> {
318	const neededAddons: ILibraryMetadata[] = [];	12✔
319	// add addons that are required by the H5P library metadata extension
320	for (const installedAddon of installedAddons) {	12✔
321	// The property addTo.player.machineNames is a custom
322	// h5p-nodejs-library extension.
UNCOV 323	if (	×
324	installedAddon.addTo?.player?.machineNames?.includes(	×
325	machineName	×
326	) \|\|
327	installedAddon.addTo?.player?.machineNames?.includes('*')	×
328	) {
UNCOV 329	log.debug(	×
330	`Addon ${LibraryName.toUberName(
331	installedAddon
332	)} will be added to the player.`
333	);
UNCOV 334	neededAddons.push(installedAddon);	×
335	}
336	}
337
338	// add addons that are required by the server configuration
339	const configRequestedAddons = [	12✔
340	...(this.config.playerAddons?.[machineName] ?? []),	72!
341	...(this.config.playerAddons?.['*'] ?? [])	72!
342	];
343	for (const addonMachineName of configRequestedAddons) {	24!
UNCOV 344	const installedAddonVersions = await this.libraryManager.listInstalledLibraries(	×
345	[addonMachineName]
346	);
UNCOV 347	if (	×
348	!neededAddons	×
UNCOV 349	.map((a) => a.machineName)	×
350	.includes(addonMachineName) &&
351	installedAddonVersions[addonMachineName] !== undefined
352	) {
UNCOV 353	log.debug(	×
354	`Addon ${addonMachineName} will be added to the player.`
355	);
356
UNCOV 357	neededAddons.push(	×
358	installedAddonVersions[addonMachineName].sort()[
359	installedAddonVersions[addonMachineName].length - 1
360	]
361	);
362	}
363	}
364
365	return neededAddons;	12✔
366	}
367
368	/**
369	* Determines which addons should be used for the parameters. It will scan
370	* the parameters for patterns specified by installed addons.
371	* @param parameters the parameters to scan
372	* @param installedAddons a list of addons installed on the system
373	* @returns a list of addons that should be used
374	*/
375	private async getAddonsByParameters(	26✔
376	parameters: any,
377	installedAddons: ILibraryMetadata[]
378	): Promise<ILibraryMetadata[]> {
379	log.debug('Checking which of the addons must be used for the content.');	12✔
380	const addonsToAdd: { [key: string]: ILibraryMetadata } = {};	12✔
381	for (const installedAddon of installedAddons) {	12✔
UNCOV 382	if (!installedAddon.addTo?.content?.types) {	×
383	continue;	×
384	}
385
UNCOV 386	for (const types of installedAddon.addTo.content.types) {	×
387	if (types.text) {	×
388	// The regex pattern in the metadata is specified like this:
389	// /mypattern/ or /mypattern/g
390	// Because of this we must extract the actual pattern and
391	// the flags and pass them to the constructor of RegExp.
UNCOV 392	const matches = /^\/(.+?)\/([gimy]+)?$/.exec(	×
393	types.text.regex
394	);
UNCOV 395	if (matches.length < 1) {	×
396	log.error(	×
397	`The addon ${LibraryName.toUberName(
398	installedAddon
399	)} contains an invalid regexp pattern in the addTo selector: ${
400	types.text.regex
401	}. This will be silently ignored, but the addon will never be used!`
402	);
UNCOV 403	continue;	×
404	}
405
UNCOV 406	if (	×
407	this.checkIfRegexIsInParameters(
408	parameters,
409	new RegExp(matches[1], matches[2])
410	)
411	) {
UNCOV 412	log.debug(	×
413	`Adding addon ${LibraryName.toUberName(
414	installedAddon
415	)} to dependencies as the regexp pattern ${
416	types.text.regex
417	} was found in the parameters.`
418	);
UNCOV 419	addonsToAdd[	×
420	installedAddon.machineName
421	] = installedAddon;
422	}
423	}
424	}
425	}
426	return Object.values(addonsToAdd);	12✔
427	}
428
429	private getDownloadPath(contentId: ContentId): string {	26✔
430	return this.urlGenerator.downloadPackage(contentId);	12✔
431	}
432
433	private async getMetadata(	26✔
434	machineName: string,
435	majorVersion: number,
436	minorVersion: number
437	): Promise<IInstalledLibrary> {
438	log.verbose(	20✔
439	`loading library ${machineName}-${majorVersion}.${minorVersion}`
440	);
441	return this.libraryStorage.getLibrary(	20✔
442	new LibraryName(machineName, majorVersion, minorVersion)
443	);
444	}
445
446	/**
447	*
448	* @param dependencies
449	* @param loaded can be left out in initial call
450	*/
451	private async getMetadataRecursive(	26✔
452	dependencies: ILibraryName[],
453	loaded: { [ubername: string]: IInstalledLibrary } = {}	44✔
454	): Promise<{ [ubername: string]: IInstalledLibrary }> {
455	log.verbose(	32✔
456	`loading libraries from dependencies: ${dependencies
457	.map((dep) => LibraryName.toUberName(dep))	20✔
458	.join(', ')}`
459	);
460	await Promise.all(	64✔
461	dependencies.map(async (dependency) => {	20✔
462	const name = dependency.machineName;	20✔
463	const majVer = dependency.majorVersion;	20✔
464	const minVer = dependency.minorVersion;	20✔
465
466	const key = LibraryName.toUberName(dependency);	20✔
467	if (key in loaded) {	20!
UNCOV 468	return;	×
469	}
470	let lib;
471	try {
472	lib = await this.getMetadata(name, majVer, minVer);	20✔
473	} catch {
UNCOV 474	log.info(	×
475	`Could not find library ${name}-${majVer}.${minVer} in storage. Silently ignoring...`
476	);
477	}
478	if (lib) {	20!
479	loaded[key] = lib;	20✔
480	await this.getMetadataRecursive(	40✔
481	lib.preloadedDependencies \|\| [],	32✔
482	loaded
483	);
484	}
485	})
486	);
487	return loaded;	32✔
488	}
489
490	private listCoreScripts(): string[] {	26✔
491	return playerAssetList.scripts.core.map(this.urlGenerator.coreFile);	36✔
492	}
493
494	private listCoreStyles(): string[] {	26✔
495	return playerAssetList.styles.core.map(this.urlGenerator.coreFile);	36✔
496	}
497	}	26✔

Lumieducation / H5P-Nodejs-library / 5a7724a5-9fc5-4784-b65b-7a945923b72b

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