@worktile/planet 19.0.0-next.0 → 19.0.0-next.1

package/esm2022/application/planet-application.service.mjs

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { shareReplay, map } from 'rxjs/operators';
+import { coerceArray } from '../helpers';
+import { AssetsLoader } from '../assets-loader';
+import { getApplicationService } from '../global-planet';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../assets-loader";
+export class PlanetApplicationService {
+    constructor(http, assetsLoader) {
+        this.http = http;
+        this.assetsLoader = assetsLoader;
+        this.apps = [];
+        this.appsMap = {};
+        if (getApplicationService()) {
+            throw new Error('PlanetApplicationService has been injected in the portal, repeated injection is not allowed');
+        }
+    }
+    register(appOrApps) {
+        const apps = coerceArray(appOrApps);
+        apps.forEach(app => {
+            if (this.appsMap[app.name]) {
+                throw new Error(`${app.name} has be registered.`);
+            }
+            this.apps.push(app);
+            this.appsMap[app.name] = app;
+        });
+    }
+    registerByUrl(url) {
+        const result = this.http.get(`${url}`).pipe(map(apps => {
+            if (apps && Array.isArray(apps)) {
+                this.register(apps);
+            }
+            else {
+                this.register(apps);
+            }
+        }), shareReplay());
+        result.subscribe();
+        return result;
+    }
+    unregister(name) {
+        if (this.appsMap[name]) {
+            delete this.appsMap[name];
+            this.apps = this.apps.filter(app => {
+                return app.name !== name;
+            });
+        }
+    }
+    getAppsByMatchedUrl(url) {
+        return this.getApps().filter(app => {
+            if (app.routerPathPrefix instanceof RegExp) {
+                return app.routerPathPrefix.test(url);
+            }
+            else {
+                return (url === app.routerPathPrefix ||
+                    (url.startsWith(app.routerPathPrefix) && ['/', '?'].includes(url[app.routerPathPrefix.length])));
+            }
+        });
+    }
+    getAppByName(name) {
+        return this.appsMap[name];
+    }
+    getAppsToPreload(excludeAppNames) {
+        return this.getApps().filter(app => {
+            if (excludeAppNames) {
+                return app.preload && !excludeAppNames.includes(app.name);
+            }
+            else {
+                return app.preload;
+            }
+        });
+    }
+    getApps() {
+        return this.apps;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: PlanetApplicationService, deps: [{ token: i1.HttpClient }, { token: i2.AssetsLoader }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: PlanetApplicationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: PlanetApplicationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.AssetsLoader }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/application/portal-application.mjs

@@ -0,0 +1,25 @@
+export class PlanetPortalApplication {
+    constructor() {
+        this.name = 'portal';
+    }
+    navigateByUrl(url, extras) {
+        return this.ngZone.run(() => {
+            return this.router.navigateByUrl(url, extras);
+        });
+    }
+    run(fn) {
+        return this.ngZone.run(() => {
+            return fn();
+        });
+    }
+    tick() {
+        this.applicationRef.tick();
+    }
+    getComponentFactory() {
+        return this.componentFactory;
+    }
+    registerComponentFactory(componentFactory) {
+        this.componentFactory = componentFactory;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/assets-loader.mjs

@@ -0,0 +1,332 @@
+import { Injectable } from '@angular/core';
+import { hashCode, isEmpty, getResourceFileName, getExtName, isObject, getAssetsBasePath, getScriptsAndStylesAssets } from './helpers';
+import { of, Observable, forkJoin, concat } from 'rxjs';
+import { map, switchMap, concatAll } from 'rxjs/operators';
+import { HttpClient } from '@angular/common/http';
+import { createSandbox } from './sandbox';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const STYLE_LINK_OR_SCRIPT_REG = /<[script|link].*?>/gi;
+const LINK_OR_SRC_REG = /(src|href)=["'](.*?[\.js|\.css])["']/i;
+const TAG_ATTRS_REG = /(type|defer|async|rel)((=["'].*?["'])|\s|\>)/gi;
+export class AssetsLoader {
+    constructor(http) {
+        this.http = http;
+        this.loadedSources = [];
+    }
+    loadScript(scriptAsset) {
+        const { src, tagName, attributes: tagAttributes } = scriptAsset;
+        const id = hashCode(src);
+        if (this.loadedSources.includes(id)) {
+            return of({
+                src: src,
+                hashCode: id,
+                loaded: true,
+                status: 'Loaded'
+            });
+        }
+        if (tagName === 'link') {
+            const LinkAttributes = tagAttributes;
+            const link = document.createElement('link');
+            link.href = src;
+            if (LinkAttributes.rel) {
+                link.rel = LinkAttributes.rel;
+            }
+            const head = document.getElementsByTagName('head')[0];
+            head.appendChild(link);
+            return of({
+                src: src,
+                hashCode: id,
+                loaded: false,
+                status: 'Preload'
+            });
+        }
+        return new Observable((observer) => {
+            const scriptAttributes = tagAttributes;
+            const script = document.createElement('script');
+            script.type = scriptAttributes?.type || 'text/javascript';
+            script.src = src;
+            if (!scriptAttributes?.defer || scriptAttributes?.defer !== 'false') {
+                script.defer = true;
+            }
+            if (!scriptAttributes?.async && scriptAttributes?.async !== 'false') {
+                script.async = true;
+            }
+            if (script['readyState']) {
+                // IE
+                script['onreadystatechange'] = () => {
+                    if (script['readyState'] === 'loaded' || script['readyState'] === 'complete') {
+                        script['onreadystatechange'] = null;
+                        observer.next({
+                            src: src,
+                            hashCode: id,
+                            loaded: true,
+                            status: 'Loaded'
+                        });
+                        observer.complete();
+                        this.loadedSources.push(id);
+                    }
+                };
+            }
+            else {
+                // Others
+                script.onload = () => {
+                    observer.next({
+                        src: src,
+                        hashCode: id,
+                        loaded: true,
+                        status: 'Loaded'
+                    });
+                    observer.complete();
+                    this.loadedSources.push(id);
+                };
+            }
+            script.onerror = error => {
+                observer.error({
+                    src: src,
+                    hashCode: id,
+                    loaded: false,
+                    status: 'Error',
+                    error: error
+                });
+                observer.complete();
+            };
+            document.body.appendChild(script);
+        });
+    }
+    loadScriptWithSandbox(app, src) {
+        const id = hashCode(src);
+        if (this.loadedSources.includes(id)) {
+            return of({
+                src: src,
+                hashCode: id,
+                loaded: true,
+                status: 'Loaded'
+            });
+        }
+        return new Observable((observer) => {
+            this.http.get(src, { responseType: 'text' }).subscribe((code) => {
+                this.loadedSources.push(id);
+                const sandbox = createSandbox(app);
+                sandbox.execScript(code, src);
+                observer.next({
+                    src: src,
+                    hashCode: id,
+                    loaded: true,
+                    status: 'Loaded'
+                });
+                observer.complete();
+            }, error => {
+                observer.error({
+                    src: src,
+                    hashCode: id,
+                    loaded: false,
+                    status: 'Error',
+                    error: error
+                });
+                observer.complete();
+            });
+        });
+    }
+    loadStyle(src) {
+        const id = hashCode(src);
+        if (this.loadedSources.includes(id)) {
+            return of({
+                src: src,
+                hashCode: id,
+                loaded: true,
+                status: 'Loaded'
+            });
+        }
+        return new Observable((observer) => {
+            const head = document.getElementsByTagName('head')[0];
+            const link = document.createElement('link');
+            link.rel = 'stylesheet';
+            link.type = 'text/css';
+            link.href = src;
+            link.media = 'all';
+            link.onload = () => {
+                observer.next({
+                    src: src,
+                    hashCode: id,
+                    loaded: true,
+                    status: 'Loaded'
+                });
+                observer.complete();
+                this.loadedSources.push(id);
+            };
+            link.onerror = error => {
+                observer.error({
+                    src: src,
+                    hashCode: id,
+                    loaded: true,
+                    status: 'Loaded',
+                    error: error
+                });
+                observer.complete();
+            };
+            head.appendChild(link);
+        });
+    }
+    loadScripts(sources, options = {
+        serial: false,
+        sandbox: false
+    }) {
+        if (isEmpty(sources)) {
+            return of(null);
+        }
+        const observables = sources.map(source => {
+            // TODO: 暂时只支持Proxy沙箱
+            if (options.sandbox && window.Proxy) {
+                return this.loadScriptWithSandbox(options.app, source.src);
+            }
+            else {
+                return this.loadScript(source);
+            }
+        });
+        if (options.serial) {
+            const a = concat(...observables).pipe(map(item => {
+                return of([item]);
+            }), concatAll());
+            return a;
+        }
+        else {
+            return forkJoin(observables).pipe();
+        }
+    }
+    loadStyles(sources) {
+        if (isEmpty(sources)) {
+            return of(null);
+        }
+        return forkJoin(sources.map(source => {
+            return this.loadStyle(source.src);
+        }));
+    }
+    loadScriptsAndStyles(scripts = [], styles = [], options) {
+        return forkJoin([this.loadScripts(scripts, options), this.loadStyles(styles)]);
+    }
+    /**
+     * <script type="module" src="http://127.0.0.1:3001/main.js" async defer></script>
+     * => [`type="module"`, "async ", "defer>"] as attributeStrMatchArr
+     * => { type: "module", async: "async", defer: "defer" } as attributes
+     */
+    parseTagAttributes(tag) {
+        const attributeStrMatchArr = tag.match(TAG_ATTRS_REG);
+        if (attributeStrMatchArr) {
+            const attributes = {};
+            attributeStrMatchArr.forEach(item => {
+                const equalSignIndex = item.indexOf('=');
+                if (equalSignIndex > 0) {
+                    // 'type="module"' => { type: "module" }
+                    const key = item.slice(0, equalSignIndex);
+                    attributes[key] = item.slice(equalSignIndex + 2, item.length - 1);
+                }
+                else {
+                    // 'async ' => 'async'
+                    // 'defer>' => 'defer'
+                    const key = item.slice(0, item.length - 1);
+                    attributes[key] = key;
+                }
+            });
+            return attributes;
+        }
+        return undefined;
+    }
+    parseManifestFromHTML(html) {
+        const result = {};
+        const matchResult = html.match(STYLE_LINK_OR_SCRIPT_REG);
+        matchResult.forEach(item => {
+            const isLinkTag = item.trim().toLowerCase().slice(1, item.indexOf(' ')) === 'link';
+            const linkOrSrcResult = item.match(LINK_OR_SRC_REG);
+            if (linkOrSrcResult && linkOrSrcResult[2]) {
+                const src = linkOrSrcResult[2];
+                const hashName = getResourceFileName(src);
+                let barSplitIndex = hashName.indexOf('-');
+                let dotSplitIndex = hashName.indexOf('.');
+                const splitIndex = barSplitIndex > -1 ? barSplitIndex : dotSplitIndex;
+                if (splitIndex > -1) {
+                    const name = hashName.slice(0, splitIndex);
+                    const ext = getExtName(hashName);
+                    const assetsTag = {
+                        src: src,
+                        tagName: isLinkTag ? 'link' : 'script'
+                    };
+                    const assetName = ext ? `${name}.${ext}` : name;
+                    if (!result[assetName]) {
+                        result[assetName] = [assetsTag];
+                    }
+                    else {
+                        result[assetName] = result[assetName].concat(assetsTag);
+                    }
+                    const attributes = this.parseTagAttributes(item);
+                    if (attributes) {
+                        assetsTag.attributes = attributes;
+                    }
+                    // const typeTagResult = item.match(TAG_TYPE_REG);
+                    // if (typeTagResult && typeTagResult[1]) {
+                    //     assetsTag.attributes = {
+                    //         type: typeTagResult[1]
+                    //     };
+                    // }
+                }
+            }
+        });
+        return result;
+    }
+    loadAppAssets(app) {
+        const basePath = getAssetsBasePath(app);
+        const manifest = app.entry ? (isObject(app.entry) ? app.entry.manifest : app.entry) : app.manifest;
+        if (manifest) {
+            const manifestExt = getExtName(manifest);
+            const isHtml = manifestExt === 'html';
+            const responseType = isHtml ? 'text' : 'json';
+            return this.loadManifest(`${manifest}?t=${new Date().getTime()}`, responseType).pipe(switchMap(manifestResult => {
+                const { scripts, styles } = getScriptsAndStylesAssets(app, basePath, manifestResult);
+                return this.loadScriptsAndStyles(scripts, styles, {
+                    app: app.name,
+                    sandbox: app.sandbox,
+                    serial: app.loadSerial
+                });
+            }));
+        }
+        else {
+            const { scripts, styles } = getScriptsAndStylesAssets(app, basePath);
+            return this.loadScriptsAndStyles(scripts, styles, {
+                app: app.name,
+                sandbox: app.sandbox,
+                serial: app.loadSerial
+            });
+        }
+    }
+    loadManifest(url, responseType = 'json') {
+        return this.http
+            .get(url, {
+            responseType: responseType
+        })
+            .pipe(map((response) => {
+            if (responseType === 'text') {
+                return this.parseManifestFromHTML(response);
+            }
+            else {
+                const result = {};
+                Object.keys(response).forEach(key => {
+                    result[key] = [
+                        {
+                            src: response[key]
+                        }
+                    ];
+                });
+                return result;
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: AssetsLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: AssetsLoader, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: AssetsLoader, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assets-loader.js","sourceRoot":"","sources":["../../../packages/planet/src/assets-loader.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { hashCode, isEmpty, getResourceFileName, getExtName, isObject, getAssetsBasePath, getScriptsAndStylesAssets } from './helpers';\nimport { of, Observable, Observer, forkJoin, concat } from 'rxjs';\nimport { map, switchMap, concatAll } from 'rxjs/operators';\nimport { HttpClient } from '@angular/common/http';\nimport { PlanetApplication, PlanetApplicationEntry } from './planet.class';\nimport { createSandbox } from './sandbox';\nimport { AssetsTagItem, LinkTagAttributes, ScriptTagAttributes } from './inner-types';\n\nconst STYLE_LINK_OR_SCRIPT_REG = /<[script|link].*?>/gi;\nconst LINK_OR_SRC_REG = /(src|href)=[\"'](.*?[\\.js|\\.css])[\"']/i;\nconst TAG_ATTRS_REG = /(type|defer|async|rel)((=[\"'].*?[\"'])|\\s|\\>)/gi;\n\nexport interface AssetsLoadResult {\n    src: string;\n    hashCode: number;\n    loaded: boolean;\n    status: string;\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class AssetsLoader {\n    private loadedSources: number[] = [];\n\n    constructor(private http: HttpClient) {}\n\n    loadScript(scriptAsset: AssetsTagItem) {\n        const { src, tagName, attributes: tagAttributes } = scriptAsset;\n        const id = hashCode(src);\n        if (this.loadedSources.includes(id)) {\n            return of({\n                src: src,\n                hashCode: id,\n                loaded: true,\n                status: 'Loaded'\n            });\n        }\n\n        if (tagName === 'link') {\n            const LinkAttributes = tagAttributes as LinkTagAttributes;\n            const link = document.createElement('link');\n            link.href = src;\n            if (LinkAttributes.rel) {\n                link.rel = LinkAttributes.rel;\n            }\n            const head = document.getElementsByTagName('head')[0];\n            head.appendChild(link);\n            return of({\n                src: src,\n                hashCode: id,\n                loaded: false,\n                status: 'Preload'\n            });\n        }\n        return new Observable((observer: Observer<AssetsLoadResult>) => {\n            const scriptAttributes = tagAttributes as ScriptTagAttributes;\n            const script: HTMLScriptElement = document.createElement('script');\n            script.type = scriptAttributes?.type || 'text/javascript';\n            script.src = src;\n            if (!scriptAttributes?.defer || scriptAttributes?.defer !== 'false') {\n                script.defer = true;\n            }\n            if (!scriptAttributes?.async && scriptAttributes?.async !== 'false') {\n                script.async = true;\n            }\n\n            if (script['readyState']) {\n                // IE\n                script['onreadystatechange'] = () => {\n                    if (script['readyState'] === 'loaded' || script['readyState'] === 'complete') {\n                        script['onreadystatechange'] = null;\n                        observer.next({\n                            src: src,\n                            hashCode: id,\n                            loaded: true,\n                            status: 'Loaded'\n                        });\n                        observer.complete();\n                        this.loadedSources.push(id);\n                    }\n                };\n            } else {\n                // Others\n                script.onload = () => {\n                    observer.next({\n                        src: src,\n                        hashCode: id,\n                        loaded: true,\n                        status: 'Loaded'\n                    });\n                    observer.complete();\n                    this.loadedSources.push(id);\n                };\n            }\n            script.onerror = error => {\n                observer.error({\n                    src: src,\n                    hashCode: id,\n                    loaded: false,\n                    status: 'Error',\n                    error: error\n                });\n                observer.complete();\n            };\n            document.body.appendChild(script);\n        });\n    }\n\n    loadScriptWithSandbox(app: string, src: string): Observable<AssetsLoadResult> {\n        const id = hashCode(src);\n        if (this.loadedSources.includes(id)) {\n            return of({\n                src: src,\n                hashCode: id,\n                loaded: true,\n                status: 'Loaded'\n            });\n        }\n        return new Observable((observer: Observer<AssetsLoadResult>) => {\n            this.http.get(src, { responseType: 'text' }).subscribe(\n                (code: string) => {\n                    this.loadedSources.push(id);\n                    const sandbox = createSandbox(app);\n                    sandbox.execScript(code, src);\n                    observer.next({\n                        src: src,\n                        hashCode: id,\n                        loaded: true,\n                        status: 'Loaded'\n                    });\n                    observer.complete();\n                },\n                error => {\n                    observer.error({\n                        src: src,\n                        hashCode: id,\n                        loaded: false,\n                        status: 'Error',\n                        error: error\n                    });\n                    observer.complete();\n                }\n            );\n        });\n    }\n\n    loadStyle(src: string): Observable<AssetsLoadResult> {\n        const id = hashCode(src);\n        if (this.loadedSources.includes(id)) {\n            return of({\n                src: src,\n                hashCode: id,\n                loaded: true,\n                status: 'Loaded'\n            });\n        }\n        return new Observable((observer: Observer<AssetsLoadResult>) => {\n            const head = document.getElementsByTagName('head')[0];\n            const link = document.createElement('link');\n            link.rel = 'stylesheet';\n            link.type = 'text/css';\n            link.href = src;\n            link.media = 'all';\n            link.onload = () => {\n                observer.next({\n                    src: src,\n                    hashCode: id,\n                    loaded: true,\n                    status: 'Loaded'\n                });\n                observer.complete();\n                this.loadedSources.push(id);\n            };\n            link.onerror = error => {\n                observer.error({\n                    src: src,\n                    hashCode: id,\n                    loaded: true,\n                    status: 'Loaded',\n                    error: error\n                });\n                observer.complete();\n            };\n            head.appendChild(link);\n        });\n    }\n\n    loadScripts(\n        sources: AssetsTagItem[],\n        options: {\n            app?: string;\n            sandbox?: boolean;\n            serial?: boolean;\n        } = {\n            serial: false,\n            sandbox: false\n        }\n    ): Observable<AssetsLoadResult[]> {\n        if (isEmpty(sources)) {\n            return of(null);\n        }\n        const observables = sources.map(source => {\n            // TODO: 暂时只支持Proxy沙箱\n            if (options.sandbox && window.Proxy) {\n                return this.loadScriptWithSandbox(options.app, source.src);\n            } else {\n                return this.loadScript(source);\n            }\n        });\n        if (options.serial) {\n            const a = concat(...observables).pipe(\n                map(item => {\n                    return of([item]);\n                }),\n                concatAll()\n            );\n            return a;\n        } else {\n            return forkJoin(observables).pipe();\n        }\n    }\n\n    loadStyles(sources: AssetsTagItem[]): Observable<AssetsLoadResult[]> {\n        if (isEmpty(sources)) {\n            return of(null);\n        }\n        return forkJoin(\n            sources.map(source => {\n                return this.loadStyle(source.src);\n            })\n        );\n    }\n\n    loadScriptsAndStyles(\n        scripts: AssetsTagItem[] = [],\n        styles: AssetsTagItem[] = [],\n        options?: {\n            app?: string;\n            sandbox?: boolean;\n            serial?: boolean;\n        }\n    ) {\n        return forkJoin([this.loadScripts(scripts, options), this.loadStyles(styles)]);\n    }\n\n    /**\n     * <script type=\"module\" src=\"http://127.0.0.1:3001/main.js\" async defer></script>\n     * => [`type=\"module\"`, \"async \", \"defer>\"] as attributeStrMatchArr\n     * => { type: \"module\", async: \"async\", defer: \"defer\" } as attributes\n     */\n    parseTagAttributes(tag: string): Record<string, string> {\n        const attributeStrMatchArr = tag.match(TAG_ATTRS_REG);\n        if (attributeStrMatchArr) {\n            const attributes: Record<string, string> = {};\n            attributeStrMatchArr.forEach(item => {\n                const equalSignIndex = item.indexOf('=');\n                if (equalSignIndex > 0) {\n                    // 'type=\"module\"' => { type: \"module\" }\n                    const key = item.slice(0, equalSignIndex);\n                    attributes[key] = item.slice(equalSignIndex + 2, item.length - 1);\n                } else {\n                    // 'async ' => 'async'\n                    // 'defer>' => 'defer'\n                    const key = item.slice(0, item.length - 1);\n                    attributes[key] = key;\n                }\n            });\n            return attributes;\n        }\n        return undefined;\n    }\n\n    parseManifestFromHTML(html: string): Record<string, AssetsTagItem[]> {\n        const result: Record<string, AssetsTagItem[]> = {};\n        const matchResult = html.match(STYLE_LINK_OR_SCRIPT_REG);\n        matchResult.forEach(item => {\n            const isLinkTag = item.trim().toLowerCase().slice(1, item.indexOf(' ')) === 'link';\n            const linkOrSrcResult = item.match(LINK_OR_SRC_REG);\n            if (linkOrSrcResult && linkOrSrcResult[2]) {\n                const src = linkOrSrcResult[2];\n                const hashName = getResourceFileName(src);\n                let barSplitIndex = hashName.indexOf('-');\n                let dotSplitIndex = hashName.indexOf('.');\n                const splitIndex = barSplitIndex > -1 ? barSplitIndex : dotSplitIndex;\n                if (splitIndex > -1) {\n                    const name = hashName.slice(0, splitIndex);\n                    const ext = getExtName(hashName);\n                    const assetsTag: AssetsTagItem = {\n                        src: src,\n                        tagName: isLinkTag ? 'link' : 'script'\n                    };\n                    const assetName = ext ? `${name}.${ext}` : name;\n                    if (!result[assetName]) {\n                        result[assetName] = [assetsTag];\n                    } else {\n                        result[assetName] = result[assetName].concat(assetsTag);\n                    }\n\n                    const attributes = this.parseTagAttributes(item);\n                    if (attributes) {\n                        assetsTag.attributes = attributes;\n                    }\n                    // const typeTagResult = item.match(TAG_TYPE_REG);\n                    // if (typeTagResult && typeTagResult[1]) {\n                    //     assetsTag.attributes = {\n                    //         type: typeTagResult[1]\n                    //     };\n                    // }\n                }\n            }\n        });\n        return result;\n    }\n\n    loadAppAssets(app: PlanetApplication) {\n        const basePath = getAssetsBasePath(app);\n        const manifest = app.entry ? (isObject<PlanetApplicationEntry>(app.entry) ? app.entry.manifest : app.entry) : app.manifest;\n        if (manifest) {\n            const manifestExt = getExtName(manifest);\n            const isHtml = manifestExt === 'html';\n            const responseType = isHtml ? 'text' : 'json';\n            return this.loadManifest(`${manifest}?t=${new Date().getTime()}`, responseType).pipe(\n                switchMap(manifestResult => {\n                    const { scripts, styles } = getScriptsAndStylesAssets(app, basePath, manifestResult);\n                    return this.loadScriptsAndStyles(scripts, styles, {\n                        app: app.name,\n                        sandbox: app.sandbox,\n                        serial: app.loadSerial\n                    });\n                })\n            );\n        } else {\n            const { scripts, styles } = getScriptsAndStylesAssets(app, basePath);\n            return this.loadScriptsAndStyles(scripts, styles, {\n                app: app.name,\n                sandbox: app.sandbox,\n                serial: app.loadSerial\n            });\n        }\n    }\n\n    loadManifest(url: string, responseType: 'text' | 'json' = 'json'): Observable<Record<string, AssetsTagItem[]>> {\n        return this.http\n            .get(url, {\n                responseType: responseType as 'json'\n            })\n            .pipe(\n                map((response: any) => {\n                    if (responseType === 'text') {\n                        return this.parseManifestFromHTML(response as string);\n                    } else {\n                        const result: Record<string, AssetsTagItem[]> = {};\n                        Object.keys(response).forEach(key => {\n                            result[key] = [\n                                {\n                                    src: response[key]\n                                }\n                            ];\n                        });\n                        return result;\n                    }\n                })\n            );\n    }\n}\n"]}