@alauda-fe/plugin-sdk 0.0.1

package/esm2022/alauda-fe-plugin-sdk.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxhdWRhLWZlLXBsdWdpbi1zZGsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL3BsdWdpbi1zZGsvc3JjL2FsYXVkYS1mZS1wbHVnaW4tc2RrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/index.mjs

@@ -0,0 +1,7 @@
+export * from './lib/app-extensions';
+export * from './lib/components';
+export * from './lib/extensions-loader';
+export * from './lib/navigation';
+export * from './lib/route';
+export * from './lib/utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL3BsdWdpbi1zZGsvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9hcHAtZXh0ZW5zaW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2V4dGVuc2lvbnMtbG9hZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL25hdmlnYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcm91dGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdXRpbHMnO1xuIl19

package/esm2022/lib/app-extensions.mjs

@@ -0,0 +1,18 @@
+import { loadExtensions } from './extensions-loader';
+let extensions;
+export function getAppExtensions(type, cluster) {
+    if (!extensions) {
+        throw new Error('Extensions not loaded');
+    }
+    return extensions.filter(ext => {
+        if (ext.cluster && cluster && ext.cluster !== cluster) {
+            return false;
+        }
+        return ext.type === type;
+    });
+}
+export async function setupAppExtensions() {
+    extensions = await loadExtensions({ types: ['service'] });
+    return extensions;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWV4dGVuc2lvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3BsdWdpbi1zZGsvc3JjL2xpYi9hcHAtZXh0ZW5zaW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWEsY0FBYyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFaEUsSUFBSSxVQUF1QixDQUFDO0FBRTVCLE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxJQUFZLEVBQUUsT0FBZ0I7SUFDN0QsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQ2hCLE1BQU0sSUFBSSxLQUFLLENBQUMsdUJBQXVCLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBQ0QsT0FBTyxVQUFVLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQzdCLElBQUksR0FBRyxDQUFDLE9BQU8sSUFBSSxPQUFPLElBQUksR0FBRyxDQUFDLE9BQU8sS0FBSyxPQUFPLEVBQUUsQ0FBQztZQUN0RCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7UUFFRCxPQUFPLEdBQUcsQ0FBQyxJQUFJLEtBQUssSUFBSSxDQUFDO0lBQzNCLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQztBQUVELE1BQU0sQ0FBQyxLQUFLLFVBQVUsa0JBQWtCO0lBQ3RDLFVBQVUsR0FBRyxNQUFNLGNBQWMsQ0FBQyxFQUFFLEtBQUssRUFBRSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUUxRCxPQUFPLFVBQVUsQ0FBQztBQUNwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXh0ZW5zaW9uLCBsb2FkRXh0ZW5zaW9ucyB9IGZyb20gJy4vZXh0ZW5zaW9ucy1sb2FkZXInO1xuXG5sZXQgZXh0ZW5zaW9uczogRXh0ZW5zaW9uW107XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRBcHBFeHRlbnNpb25zKHR5cGU6IHN0cmluZywgY2x1c3Rlcj86IHN0cmluZykge1xuICBpZiAoIWV4dGVuc2lvbnMpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ0V4dGVuc2lvbnMgbm90IGxvYWRlZCcpO1xuICB9XG4gIHJldHVybiBleHRlbnNpb25zLmZpbHRlcihleHQgPT4ge1xuICAgIGlmIChleHQuY2x1c3RlciAmJiBjbHVzdGVyICYmIGV4dC5jbHVzdGVyICE9PSBjbHVzdGVyKSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuXG4gICAgcmV0dXJuIGV4dC50eXBlID09PSB0eXBlO1xuICB9KTtcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHNldHVwQXBwRXh0ZW5zaW9ucygpIHtcbiAgZXh0ZW5zaW9ucyA9IGF3YWl0IGxvYWRFeHRlbnNpb25zKHsgdHlwZXM6IFsnc2VydmljZSddIH0pO1xuXG4gIHJldHVybiBleHRlbnNpb25zO1xufVxuIl19

package/esm2022/lib/components/index.mjs

@@ -0,0 +1,2 @@
+export * from './remote-component-outlet/component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3BsdWdpbi1zZGsvc3JjL2xpYi9jb21wb25lbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3JlbW90ZS1jb21wb25lbnQtb3V0bGV0L2NvbXBvbmVudCc7XG4iXX0=

package/esm2022/lib/components/remote-component-outlet/component.mjs

@@ -0,0 +1,47 @@
+import { NgComponentOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, effect, input, signal, } from '@angular/core';
+import { loadRemote } from '../../utils';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+function RemoteComponentOutletComponent_Conditional_0_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0);
+} }
+function RemoteComponentOutletComponent_Conditional_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, RemoteComponentOutletComponent_Conditional_0_ng_container_0_Template, 1, 0, "ng-container", 0);
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngComponentOutlet", ctx_r0.component())("ngComponentOutletInputs", ctx_r0.inputs())("ngComponentOutletInjector", ctx_r0.injector())("ngComponentOutletContent", ctx_r0.content());
+} }
+function RemoteComponentOutletComponent_Conditional_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵprojection(0);
+} }
+export class RemoteComponentOutletComponent {
+    constructor() {
+        this.remoteComponents = signal({});
+        this.name = input.required();
+        this.entrypoint = input.required();
+        this.expose = input('./Components');
+        this.inputs = input();
+        this.injector = input();
+        this.content = input();
+        this.component = computed(() => this.remoteComponents()[this.name()]);
+        effect(async () => {
+            if (this.entrypoint()) {
+                this.remoteComponents.set((await loadRemote(this.entrypoint(), this.expose())).default);
+            }
+        }, { allowSignalWrites: true });
+    }
+    static { this.ɵfac = function RemoteComponentOutletComponent_Factory(t) { return new (t || RemoteComponentOutletComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: RemoteComponentOutletComponent, selectors: [["acl-remote-component-outlet"]], inputs: { name: [1, "name"], entrypoint: [1, "entrypoint"], expose: [1, "expose"], inputs: [1, "inputs"], injector: [1, "injector"], content: [1, "content"] }, standalone: true, features: [i0.ɵɵStandaloneFeature], ngContentSelectors: _c0, decls: 2, vars: 1, consts: [[4, "ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent"]], template: function RemoteComponentOutletComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵtemplate(0, RemoteComponentOutletComponent_Conditional_0_Template, 1, 4, "ng-container")(1, RemoteComponentOutletComponent_Conditional_1_Template, 1, 0);
+        } if (rf & 2) {
+            i0.ɵɵconditional(ctx.component() ? 0 : 1);
+        } }, dependencies: [NgComponentOutlet], encapsulation: 2, changeDetection: 0 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RemoteComponentOutletComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-remote-component-outlet', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [NgComponentOutlet], template: "@if (component()) {\n  <ng-container\n    *ngComponentOutlet=\"\n      component();\n      inputs: inputs();\n      injector: injector();\n      content: content()\n    \"\n  ></ng-container>\n} @else {\n  <ng-content></ng-content>\n}\n" }]
+    }], () => [], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(RemoteComponentOutletComponent, { className: "RemoteComponentOutletComponent", filePath: "lib/components/remote-component-outlet/component.ts", lineNumber: 21 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/extensions-loader.mjs

@@ -0,0 +1,51 @@
+import { attachAuthorizationHeader } from '@alauda-fe/common';
+import { isLocalEnv } from './utils';
+export async function loadExtensions(query = {}) {
+    return isLocalEnv()
+        ? await loadDevExtensions(query)
+        : await loadProdExtensions(query);
+}
+async function loadDevExtensions(query = {}) {
+    return await fetch(`/dev-plugin/console-plugin.json`)
+        .then(res => {
+        if (!res.ok) {
+            throw new Error('Failed to fetch local dev extensions');
+        }
+        return res.json();
+    })
+        .then((plugin) => plugin.extensions.map(ext => ({
+        ...ext,
+        entrypoint: 'http://localhost:5000',
+    })))
+        .catch(() => {
+        console.warn('Failed to fetch local dev extensions, loading prod extensions');
+        return loadProdExtensions(query);
+    });
+}
+async function loadProdExtensions(query = {}) {
+    const reqPrefix = isLocalEnv() ? '/api-gateway' : '';
+    const queryString = Object.entries(query)
+        .map(([key, value]) => `${key}=${value.join(',')}`)
+        .join(';');
+    return await fetch(`${reqPrefix}/frontend-plugins/clusters/console-plugins${queryString && '?filter=' + encodeURIComponent(queryString)}`, {
+        headers: attachAuthorizationHeader(),
+    })
+        .then(res => {
+        if (!res.ok) {
+            throw new Error('Failed to fetch extensions');
+        }
+        return res.json();
+    })
+        .then((rawPlugins) => Object.entries(rawPlugins).reduce((acc, [cluster, plugins]) => acc.concat(plugins.flatMap(plugin => JSON.parse(plugin['console-plugin.json']).extensions.map(ext => ({
+        ...ext,
+        cluster,
+        operator: plugin.operator,
+        version: plugin.version,
+        entrypoint: `${reqPrefix}/clusters-rewrite/${cluster}${plugin.path}`,
+    })))), []))
+        .catch(err => {
+        console.error(err);
+        return [];
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZW5zaW9ucy1sb2FkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3BsdWdpbi1zZGsvc3JjL2xpYi9leHRlbnNpb25zLWxvYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUU5RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBRXJDLE1BQU0sQ0FBQyxLQUFLLFVBQVUsY0FBYyxDQUFDLFFBQXlCLEVBQUU7SUFDOUQsT0FBTyxVQUFVLEVBQUU7UUFDakIsQ0FBQyxDQUFDLE1BQU0saUJBQWlCLENBQUMsS0FBSyxDQUFDO1FBQ2hDLENBQUMsQ0FBQyxNQUFNLGtCQUFrQixDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ3RDLENBQUM7QUFFRCxLQUFLLFVBQVUsaUJBQWlCLENBQzlCLFFBQXlCLEVBQUU7SUFFM0IsT0FBTyxNQUFNLEtBQUssQ0FBQyxpQ0FBaUMsQ0FBQztTQUNsRCxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUU7UUFDVixJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxDQUFDO1lBQ1osTUFBTSxJQUFJLEtBQUssQ0FBQyxzQ0FBc0MsQ0FBQyxDQUFDO1FBQzFELENBQUM7UUFDRCxPQUFPLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNwQixDQUFDLENBQUM7U0FDRCxJQUFJLENBQUMsQ0FBQyxNQUFrQixFQUFFLEVBQUUsQ0FDM0IsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQzVCLEdBQUcsR0FBRztRQUNOLFVBQVUsRUFBRSx1QkFBdUI7S0FDcEMsQ0FBQyxDQUFDLENBQ0o7U0FDQSxLQUFLLENBQUMsR0FBRyxFQUFFO1FBQ1YsT0FBTyxDQUFDLElBQUksQ0FDViwrREFBK0QsQ0FDaEUsQ0FBQztRQUNGLE9BQU8sa0JBQWtCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbkMsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDO0FBRUQsS0FBSyxVQUFVLGtCQUFrQixDQUMvQixRQUF5QixFQUFFO0lBRTNCLE1BQU0sU0FBUyxHQUFHLFVBQVUsRUFBRSxDQUFDLENBQUMsQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztJQUNyRCxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztTQUN0QyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1NBQ2xELElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUViLE9BQU8sTUFBTSxLQUFLLENBQ2hCLEdBQUcsU0FBUyw2Q0FBNkMsV0FBVyxJQUFJLFVBQVUsR0FBRyxrQkFBa0IsQ0FBQyxXQUFXLENBQUMsRUFBRSxFQUN0SDtRQUNFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRTtLQUNyQyxDQUNGO1NBQ0UsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQ1YsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsQ0FBQztZQUNaLE1BQU0sSUFBSSxLQUFLLENBQUMsNEJBQTRCLENBQUMsQ0FBQztRQUNoRCxDQUFDO1FBQ0QsT0FBTyxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDcEIsQ0FBQyxDQUFDO1NBQ0QsSUFBSSxDQUFDLENBQUMsVUFBc0IsRUFBRSxFQUFFLENBQy9CLE1BQU0sQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUMsTUFBTSxDQUMvQixDQUFDLEdBQUcsRUFBRSxDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsRUFBRSxFQUFFLENBQzFCLEdBQUcsQ0FBQyxNQUFNLENBQ1IsT0FBTyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUVyQixJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxDQUN6QyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZCLEdBQUcsR0FBRztRQUNOLE9BQU87UUFDUCxRQUFRLEVBQUUsTUFBTSxDQUFDLFFBQVE7UUFDekIsT0FBTyxFQUFFLE1BQU0sQ0FBQyxPQUFPO1FBQ3ZCLFVBQVUsRUFBRSxHQUFHLFNBQVMscUJBQXFCLE9BQU8sR0FBRyxNQUFNLENBQUMsSUFBSSxFQUFFO0tBQ3JFLENBQUMsQ0FBQyxDQUNKLENBQ0YsRUFDSCxFQUFpQixDQUNsQixDQUNGO1NBQ0EsS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQ1gsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNuQixPQUFPLEVBQUUsQ0FBQztJQUNaLENBQUMsQ0FBQyxDQUFDO0FBQ1AsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGF0dGFjaEF1dGhvcml6YXRpb25IZWFkZXIgfSBmcm9tICdAYWxhdWRhLWZlL2NvbW1vbic7XG5cbmltcG9ydCB7IGlzTG9jYWxFbnYgfSBmcm9tICcuL3V0aWxzJztcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGxvYWRFeHRlbnNpb25zKHF1ZXJ5OiBFeHRlbnNpb25zUXVlcnkgPSB7fSkge1xuICByZXR1cm4gaXNMb2NhbEVudigpXG4gICAgPyBhd2FpdCBsb2FkRGV2RXh0ZW5zaW9ucyhxdWVyeSlcbiAgICA6IGF3YWl0IGxvYWRQcm9kRXh0ZW5zaW9ucyhxdWVyeSk7XG59XG5cbmFzeW5jIGZ1bmN0aW9uIGxvYWREZXZFeHRlbnNpb25zKFxuICBxdWVyeTogRXh0ZW5zaW9uc1F1ZXJ5ID0ge30sXG4pOiBQcm9taXNlPEV4dGVuc2lvbltdPiB7XG4gIHJldHVybiBhd2FpdCBmZXRjaChgL2Rldi1wbHVnaW4vY29uc29sZS1wbHVnaW4uanNvbmApXG4gICAgLnRoZW4ocmVzID0+IHtcbiAgICAgIGlmICghcmVzLm9rKSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcignRmFpbGVkIHRvIGZldGNoIGxvY2FsIGRldiBleHRlbnNpb25zJyk7XG4gICAgICB9XG4gICAgICByZXR1cm4gcmVzLmpzb24oKTtcbiAgICB9KVxuICAgIC50aGVuKChwbHVnaW46IFBsdWdpbkpTT04pID0+XG4gICAgICBwbHVnaW4uZXh0ZW5zaW9ucy5tYXAoZXh0ID0+ICh7XG4gICAgICAgIC4uLmV4dCxcbiAgICAgICAgZW50cnlwb2ludDogJ2h0dHA6Ly9sb2NhbGhvc3Q6NTAwMCcsXG4gICAgICB9KSksXG4gICAgKVxuICAgIC5jYXRjaCgoKSA9PiB7XG4gICAgICBjb25zb2xlLndhcm4oXG4gICAgICAgICdGYWlsZWQgdG8gZmV0Y2ggbG9jYWwgZGV2IGV4dGVuc2lvbnMsIGxvYWRpbmcgcHJvZCBleHRlbnNpb25zJyxcbiAgICAgICk7XG4gICAgICByZXR1cm4gbG9hZFByb2RFeHRlbnNpb25zKHF1ZXJ5KTtcbiAgICB9KTtcbn1cblxuYXN5bmMgZnVuY3Rpb24gbG9hZFByb2RFeHRlbnNpb25zKFxuICBxdWVyeTogRXh0ZW5zaW9uc1F1ZXJ5ID0ge30sXG4pOiBQcm9taXNlPEV4dGVuc2lvbltdPiB7XG4gIGNvbnN0IHJlcVByZWZpeCA9IGlzTG9jYWxFbnYoKSA/ICcvYXBpLWdhdGV3YXknIDogJyc7XG4gIGNvbnN0IHF1ZXJ5U3RyaW5nID0gT2JqZWN0LmVudHJpZXMocXVlcnkpXG4gICAgLm1hcCgoW2tleSwgdmFsdWVdKSA9PiBgJHtrZXl9PSR7dmFsdWUuam9pbignLCcpfWApXG4gICAgLmpvaW4oJzsnKTtcblxuICByZXR1cm4gYXdhaXQgZmV0Y2goXG4gICAgYCR7cmVxUHJlZml4fS9mcm9udGVuZC1wbHVnaW5zL2NsdXN0ZXJzL2NvbnNvbGUtcGx1Z2lucyR7cXVlcnlTdHJpbmcgJiYgJz9maWx0ZXI9JyArIGVuY29kZVVSSUNvbXBvbmVudChxdWVyeVN0cmluZyl9YCxcbiAgICB7XG4gICAgICBoZWFkZXJzOiBhdHRhY2hBdXRob3JpemF0aW9uSGVhZGVyKCksXG4gICAgfSxcbiAgKVxuICAgIC50aGVuKHJlcyA9PiB7XG4gICAgICBpZiAoIXJlcy5vaykge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ0ZhaWxlZCB0byBmZXRjaCBleHRlbnNpb25zJyk7XG4gICAgICB9XG4gICAgICByZXR1cm4gcmVzLmpzb24oKTtcbiAgICB9KVxuICAgIC50aGVuKChyYXdQbHVnaW5zOiBSYXdQbHVnaW5zKSA9PlxuICAgICAgT2JqZWN0LmVudHJpZXMocmF3UGx1Z2lucykucmVkdWNlKFxuICAgICAgICAoYWNjLCBbY2x1c3RlciwgcGx1Z2luc10pID0+XG4gICAgICAgICAgYWNjLmNvbmNhdChcbiAgICAgICAgICAgIHBsdWdpbnMuZmxhdE1hcChwbHVnaW4gPT5cbiAgICAgICAgICAgICAgKFxuICAgICAgICAgICAgICAgIEpTT04ucGFyc2UocGx1Z2luWydjb25zb2xlLXBsdWdpbi5qc29uJ10pIGFzIFBsdWdpbkpTT05cbiAgICAgICAgICAgICAgKS5leHRlbnNpb25zLm1hcChleHQgPT4gKHtcbiAgICAgICAgICAgICAgICAuLi5leHQsXG4gICAgICAgICAgICAgICAgY2x1c3RlcixcbiAgICAgICAgICAgICAgICBvcGVyYXRvcjogcGx1Z2luLm9wZXJhdG9yLFxuICAgICAgICAgICAgICAgIHZlcnNpb246IHBsdWdpbi52ZXJzaW9uLFxuICAgICAgICAgICAgICAgIGVudHJ5cG9pbnQ6IGAke3JlcVByZWZpeH0vY2x1c3RlcnMtcmV3cml0ZS8ke2NsdXN0ZXJ9JHtwbHVnaW4ucGF0aH1gLFxuICAgICAgICAgICAgICB9KSksXG4gICAgICAgICAgICApLFxuICAgICAgICAgICksXG4gICAgICAgIFtdIGFzIEV4dGVuc2lvbltdLFxuICAgICAgKSxcbiAgICApXG4gICAgLmNhdGNoKGVyciA9PiB7XG4gICAgICBjb25zb2xlLmVycm9yKGVycik7XG4gICAgICByZXR1cm4gW107XG4gICAgfSk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXh0ZW5zaW9uc1F1ZXJ5IHtcbiAgdHlwZXM/OiBzdHJpbmdbXTtcbiAgY2x1c3RlcnM/OiBzdHJpbmdbXTtcbiAgb3BlcmF0b3JzPzogc3RyaW5nW107XG4gIGNoYW5uZWxzPzogc3RyaW5nW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXh0ZW5zaW9uPFQgPSBhbnk+IGV4dGVuZHMgUmF3RXh0ZW5zaW9uPFQ+IHtcbiAgY2x1c3Rlcj86IHN0cmluZztcbiAgb3BlcmF0b3I/OiBzdHJpbmc7XG4gIHZlcnNpb24/OiBzdHJpbmc7XG4gIGVudHJ5cG9pbnQ6IHN0cmluZztcbn1cblxuaW50ZXJmYWNlIFJhd1BsdWdpbnMge1xuICBbY2x1c3Rlcjogc3RyaW5nXTogQXJyYXk8e1xuICAgIG9wZXJhdG9yOiBzdHJpbmc7XG4gICAgdmVyc2lvbjogc3RyaW5nO1xuICAgIHBhdGg6IHN0cmluZztcbiAgICAnY29uc29sZS1wbHVnaW4uanNvbic6IHN0cmluZztcbiAgfT47XG59XG5cbmludGVyZmFjZSBQbHVnaW5KU09OIHtcbiAgZXh0ZW5zaW9uczogUmF3RXh0ZW5zaW9uW107XG59XG5cbmludGVyZmFjZSBSYXdFeHRlbnNpb248VCA9IGFueT4ge1xuICB0eXBlOiBzdHJpbmc7XG4gIG9wdGlvbnM6IFQ7XG59XG4iXX0=

package/esm2022/lib/navigation.mjs

@@ -0,0 +1,103 @@
+import { getAppExtensions } from './app-extensions';
+import { filterLatestVersion } from './utils';
+export function getRemoteNavigations(scope, locale) {
+    if (!scope) {
+        return [];
+    }
+    const exts = getAppExtensions(scope + '/navigation');
+    return filterLatestVersion((options) => options.name)(exts)
+        .map(ext => ext.options)
+        .map(options => translateLabel(locale, options));
+}
+export function getRemoteNavigationGroups(scope, locale) {
+    if (!scope) {
+        return [];
+    }
+    const exts = getAppExtensions(scope + '/navigation/group');
+    return filterLatestVersion((options) => options.name)(exts)
+        .map(ext => ext.options)
+        .map(options => translateLabel(locale, options));
+}
+export function insertNavItem(source, remotes) {
+    remotes.forEach(remote => {
+        if (remote.insertAfter) {
+            const r = insert('after', remote.insertAfter, [], source, remote);
+            if (r.matched) {
+                source = r.result;
+                return;
+            }
+        }
+        if (remote.insertBefore) {
+            const r = insert('before', remote.insertBefore, [], source, remote);
+            if (r.matched) {
+                source = r.result;
+                return;
+            }
+        }
+        source = source.concat({
+            ...remote,
+            key: remote.key ?? remote.name,
+            children: remote.children
+                ? remote.children.map(child => ({
+                    ...child,
+                    key: child.key ?? child.name,
+                }))
+                : null,
+        });
+    });
+    return source;
+}
+export function insertNavGroupItem(source, remotes) {
+    return source.map(group => {
+        const groupRemotes = remotes.filter(remote => remote.group === group.name);
+        return { ...group, items: insertNavItem(group.items, groupRemotes) };
+    });
+}
+function translateLabel(locale, item) {
+    return {
+        ...item,
+        children: item.children
+            ? item.children.map(c => translateLabel(locale, c))
+            : null,
+        label: typeof item.displayName === 'string'
+            ? item.displayName
+            : item.displayName[locale] || item.displayName['en'],
+    };
+}
+function insert(position, anchor, namePath, target, item) {
+    const offset = position === 'before' ? 0 : 1;
+    anchor = Array.isArray(anchor) ? anchor : [anchor];
+    for (const currentAnchor of anchor) {
+        for (let i = 0; i < target.length; i++) {
+            if (target[i].name === currentAnchor) {
+                return {
+                    result: [
+                        ...target.slice(0, i + offset),
+                        { ...item, key: namePath.join('/') + item.name },
+                        ...target.slice(i + offset),
+                    ],
+                    matched: true,
+                };
+            }
+            if (target[i].children) {
+                const { result, matched } = insert(position, currentAnchor, namePath.concat(target[i].name), target[i].children, item);
+                if (matched) {
+                    return {
+                        result: target.map((item, index) => index === i
+                            ? {
+                                ...item,
+                                children: result,
+                            }
+                            : item),
+                        matched: true,
+                    };
+                }
+            }
+        }
+    }
+    return {
+        result: target,
+        matched: false,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation.js","sourceRoot":"","sources":["../../../../../libs/plugin-sdk/src/lib/navigation.ts"],"names":[],"mappings":"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","sourcesContent":["import type { NavGroupConfig, NavItemConfig } from '@alauda-fe/common';\n\nimport { getAppExtensions } from './app-extensions';\nimport { filterLatestVersion } from './utils';\n\nexport function getRemoteNavigations(\n  scope: string,\n  locale: string,\n): RemoteNavigationItemRoot[] {\n  if (!scope) {\n    return [];\n  }\n\n  const exts = getAppExtensions(scope + '/navigation');\n\n  return filterLatestVersion((options: { name: string }) => options.name)(exts)\n    .map(ext => ext.options as RemoteNavigationItemRoot)\n    .map(options => translateLabel(locale, options));\n}\n\nexport function getRemoteNavigationGroups(\n  scope: string,\n  locale: string,\n): RemoteNavigationItemRoot[] {\n  if (!scope) {\n    return [];\n  }\n\n  const exts = getAppExtensions(scope + '/navigation/group');\n\n  return filterLatestVersion((options: { name: string }) => options.name)(exts)\n    .map(ext => ext.options as RemoteNavigationItemRoot)\n    .map(options => translateLabel(locale, options));\n}\n\nexport function insertNavItem(\n  source: NavItemConfig[],\n  remotes: RemoteNavigationItemRoot[],\n): NavItemConfig[] {\n  remotes.forEach(remote => {\n    if (remote.insertAfter) {\n      const r = insert('after', remote.insertAfter, [], source, remote);\n      if (r.matched) {\n        source = r.result;\n        return;\n      }\n    }\n\n    if (remote.insertBefore) {\n      const r = insert('before', remote.insertBefore, [], source, remote);\n      if (r.matched) {\n        source = r.result;\n        return;\n      }\n    }\n\n    source = source.concat({\n      ...remote,\n      key: remote.key ?? remote.name,\n      children: remote.children\n        ? remote.children.map(child => ({\n            ...child,\n            key: child.key ?? child.name,\n          }))\n        : null,\n    });\n  });\n\n  return source;\n}\n\nexport function insertNavGroupItem(\n  source: NavGroupConfig[],\n  remotes: RemoteNavigationItemRoot[],\n): NavGroupConfig[] {\n  return source.map(group => {\n    const groupRemotes = remotes.filter(remote => remote.group === group.name);\n    return { ...group, items: insertNavItem(group.items, groupRemotes) };\n  });\n}\n\nexport interface RemoteNavigationItem extends NavItemConfig {\n  group?: string;\n  displayName: string | Record<string, string>;\n  children?: RemoteNavigationItem[];\n}\n\nexport interface RemoteNavigationItemRoot extends RemoteNavigationItem {\n  insertAfter?: string | string[];\n  insertBefore?: string | string[];\n}\n\nfunction translateLabel(\n  locale: string,\n  item: RemoteNavigationItem,\n): RemoteNavigationItem {\n  return {\n    ...item,\n    children: item.children\n      ? item.children.map(c => translateLabel(locale, c))\n      : null,\n    label:\n      typeof item.displayName === 'string'\n        ? item.displayName\n        : item.displayName[locale] || item.displayName['en'],\n  };\n}\n\nfunction insert(\n  position: 'before' | 'after',\n  anchor: string | string[],\n  namePath: string[],\n  target: NavItemConfig[],\n  item: RemoteNavigationItemRoot,\n): { result: NavItemConfig[]; matched: boolean } {\n  const offset = position === 'before' ? 0 : 1;\n  anchor = Array.isArray(anchor) ? anchor : [anchor];\n\n  for (const currentAnchor of anchor) {\n    for (let i = 0; i < target.length; i++) {\n      if (target[i].name === currentAnchor) {\n        return {\n          result: [\n            ...target.slice(0, i + offset),\n            { ...item, key: namePath.join('/') + item.name },\n            ...target.slice(i + offset),\n          ],\n          matched: true,\n        };\n      }\n\n      if (target[i].children) {\n        const { result, matched } = insert(\n          position,\n          currentAnchor,\n          namePath.concat(target[i].name),\n          target[i].children,\n          item,\n        );\n        if (matched) {\n          return {\n            result: target.map((item, index) =>\n              index === i\n                ? {\n                    ...item,\n                    children: result,\n                  }\n                : item,\n            ),\n            matched: true,\n          };\n        }\n      }\n    }\n  }\n\n  return {\n    result: target,\n    matched: false,\n  };\n}\n"]}

package/esm2022/lib/route.mjs

@@ -0,0 +1,18 @@
+import { getAppExtensions } from './app-extensions';
+import { filterLatestVersion, loadRemote } from './utils';
+export function mapToRoute(ext, addition = {}) {
+    return {
+        path: ext.options.path,
+        loadChildren: () => loadRemote(ext.entrypoint, ext.options.expose ?? './Routes').then(m => m.default),
+        ...addition,
+    };
+}
+export function getRootRoutes(scope) {
+    const exts = getAppExtensions(scope + '/routes/root');
+    return filterLatestVersion((options) => options.path)(exts).map(ext => mapToRoute(ext));
+}
+export function getFeatureRoutes(scope) {
+    const exts = getAppExtensions(scope + '/routes/feature');
+    return filterLatestVersion((options) => options.path)(exts).map(ext => mapToRoute(ext));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils.mjs

@@ -0,0 +1,34 @@
+import { loadRemoteModule, setRemoteDefinitions } from '@nx/angular/mf';
+import { compare } from 'compare-versions';
+const remoteRecord = new Set();
+export function isLocalEnv() {
+    return location.hostname === 'localhost';
+}
+export function loadRemote(remote, module) {
+    if (!remoteRecord.has(remote)) {
+        remoteRecord.add(remote);
+        setRemoteDefinitions({ [remote]: remote });
+    }
+    return loadRemoteModule(remote, module);
+}
+export function filterLatestVersion(identity) {
+    return (exts) => exts.reduce((acc, ext) => {
+        const existedIndex = acc.findIndex(a => a.operator === ext.operator &&
+            identity(a.options) === identity(ext.options));
+        if (existedIndex === -1) {
+            acc.push(ext);
+        }
+        else {
+            try {
+                acc[existedIndex] = compare(acc[existedIndex].version, ext.version, '>=')
+                    ? acc[existedIndex]
+                    : ext;
+            }
+            catch {
+                console.error(`Error when comparing operator (${acc[existedIndex].operator}) versions (${acc[existedIndex].version}, ${ext.version}). Using ${acc[existedIndex].version} from cluster ${acc[existedIndex].cluster}`);
+            }
+        }
+        return acc;
+    }, []);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/app-extensions';
+export * from './lib/components';
+export * from './lib/extensions-loader';
+export * from './lib/navigation';
+export * from './lib/route';
+export * from './lib/utils';

package/lib/app-extensions.d.ts

@@ -0,0 +1,3 @@
+import { Extension } from './extensions-loader';
+export declare function getAppExtensions(type: string, cluster?: string): Extension<any>[];
+export declare function setupAppExtensions(): Promise<Extension<any>[]>;

package/lib/components/index.d.ts

@@ -0,0 +1 @@
+export * from './remote-component-outlet/component';

package/lib/components/remote-component-outlet/component.d.ts

@@ -0,0 +1,15 @@
+import { Component, Type } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class RemoteComponentOutletComponent {
+    private remoteComponents;
+    name: import("@angular/core").InputSignal<string>;
+    entrypoint: import("@angular/core").InputSignal<string>;
+    expose: import("@angular/core").InputSignal<string>;
+    inputs: import("@angular/core").InputSignal<Record<string, unknown>>;
+    injector: import("@angular/core").InputSignal<import("@angular/core").Injector>;
+    content: import("@angular/core").InputSignal<any[][]>;
+    component: import("@angular/core").Signal<Type<Component>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoteComponentOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RemoteComponentOutletComponent, "acl-remote-component-outlet", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "entrypoint": { "alias": "entrypoint"; "required": true; "isSignal": true; }; "expose": { "alias": "expose"; "required": false; "isSignal": true; }; "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "injector": { "alias": "injector"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/extensions-loader.d.ts

@@ -0,0 +1,18 @@
+export declare function loadExtensions(query?: ExtensionsQuery): Promise<Extension<any>[]>;
+export interface ExtensionsQuery {
+    types?: string[];
+    clusters?: string[];
+    operators?: string[];
+    channels?: string[];
+}
+export interface Extension<T = any> extends RawExtension<T> {
+    cluster?: string;
+    operator?: string;
+    version?: string;
+    entrypoint: string;
+}
+interface RawExtension<T = any> {
+    type: string;
+    options: T;
+}
+export {};

package/lib/navigation.d.ts

@@ -0,0 +1,14 @@
+import type { NavGroupConfig, NavItemConfig } from '@alauda-fe/common';
+export declare function getRemoteNavigations(scope: string, locale: string): RemoteNavigationItemRoot[];
+export declare function getRemoteNavigationGroups(scope: string, locale: string): RemoteNavigationItemRoot[];
+export declare function insertNavItem(source: NavItemConfig[], remotes: RemoteNavigationItemRoot[]): NavItemConfig[];
+export declare function insertNavGroupItem(source: NavGroupConfig[], remotes: RemoteNavigationItemRoot[]): NavGroupConfig[];
+export interface RemoteNavigationItem extends NavItemConfig {
+    group?: string;
+    displayName: string | Record<string, string>;
+    children?: RemoteNavigationItem[];
+}
+export interface RemoteNavigationItemRoot extends RemoteNavigationItem {
+    insertAfter?: string | string[];
+    insertBefore?: string | string[];
+}

package/lib/route.d.ts

@@ -0,0 +1,9 @@
+import { Route } from '@angular/router';
+import { Extension } from './extensions-loader';
+export declare function mapToRoute(ext: Extension<RouteOptions>, addition?: Partial<Route>): Route;
+export declare function getRootRoutes(scope: string): Route[];
+export declare function getFeatureRoutes(scope: string): Route[];
+export interface RouteOptions {
+    path: string;
+    expose?: string;
+}

package/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import { Extension } from './extensions-loader';
+export declare function isLocalEnv(): boolean;
+export declare function loadRemote(remote: string, module: string): Promise<any>;
+export declare function filterLatestVersion<O = any>(identity: (ext: O) => unknown): (exts: Array<Extension<O>>) => Array<Extension<O>>;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@alauda-fe/plugin-sdk",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@nx/angular": "^16.10.0"
+  },
+  "dependencies": {
+    "compare-versions": "^6.1.0",
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "esm2022/alauda-fe-plugin-sdk.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/alauda-fe-plugin-sdk.mjs",
+      "esm": "./esm2022/alauda-fe-plugin-sdk.mjs",
+      "default": "./esm2022/alauda-fe-plugin-sdk.mjs"
+    }
+  }
+}