@decaf-ts/integrations 0.3.12 → 0.4.1-0

package/lib/esm/plugins/kibana/templates.js

@@ -0,0 +1,499 @@
+/**
+ * @module integrations/plugins/kibana/templates
+ * @summary Version-parameterized source templates for the Kibana embed plugin.
+ * @description Holds the generated plugin source as string templates. These
+ * are materialized onto disk by the installer. The source is the reference
+ * multi-tenant embed plugin preserved in DECAF-40 §8. There is never space
+ * switching; the plugin is org-agnostic and the current Kibana space comes
+ * from the request/session/proxy context.
+ */
+import { KIBANA_APP_ID, KIBANA_PLUGIN_ID, KIBANA_PLUGIN_VERSION } from "./manifest.js";
+const TS_CONFIG = `{
+  "extends": "../../tsconfig.json",
+  "include": ["public/**/*", "server/**/*"]
+}
+`;
+const PUBLIC_TYPES = `import type {
+  AppMountParameters,
+  CoreSetup,
+  CoreStart,
+  Plugin
+} from '@kbn/core/public';
+
+import type { DashboardStart } from '@kbn/dashboard-plugin/public';
+import type { EmbeddableStart } from '@kbn/embeddable-plugin/public';
+import type { DataPublicPluginStart } from '@kbn/data-plugin/public';
+
+export interface OrgDashboardEmbedSetupDeps {}
+
+export interface OrgDashboardEmbedStartDeps {
+  dashboard: DashboardStart;
+  embeddable: EmbeddableStart;
+  data: DataPublicPluginStart;
+}
+
+export type OrgDashboardEmbedPlugin = Plugin<
+  void,
+  void,
+  OrgDashboardEmbedSetupDeps,
+  OrgDashboardEmbedStartDeps
+>;
+
+export interface MountAppArgs {
+  coreStart: CoreStart;
+  depsStart: OrgDashboardEmbedStartDeps;
+  params: AppMountParameters;
+}
+`;
+const PUBLIC_INDEX = `import type { OrgDashboardEmbedPlugin } from './types';
+import { OrgDashboardEmbedPluginImpl } from './plugin';
+
+export function plugin(): OrgDashboardEmbedPlugin {
+  return new OrgDashboardEmbedPluginImpl();
+}
+`;
+const PUBLIC_PLUGIN = `import React from 'react';
+import ReactDOM from 'react-dom';
+
+import type { CoreSetup, CoreStart } from '@kbn/core/public';
+import type {
+  OrgDashboardEmbedPlugin,
+  OrgDashboardEmbedSetupDeps,
+  OrgDashboardEmbedStartDeps
+} from './types';
+
+export class OrgDashboardEmbedPluginImpl implements OrgDashboardEmbedPlugin {
+  public setup(
+    core: CoreSetup<OrgDashboardEmbedStartDeps>,
+    deps: OrgDashboardEmbedSetupDeps
+  ) {
+    core.application.register({
+      id: '${KIBANA_APP_ID}',
+      title: 'Dashboard Embed',
+      chromeless: true,
+      visibleIn: [],
+      async mount(params) {
+        const [coreStart, depsStart] = await core.getStartServices();
+        const { OrgDashboardEmbedApp } = await import('./application');
+
+        ReactDOM.render(
+          <OrgDashboardEmbedApp
+            coreStart={coreStart}
+            depsStart={depsStart}
+            params={params}
+          />,
+          params.element
+        );
+
+        return () => ReactDOM.unmountComponentAtNode(params.element);
+      }
+    });
+  }
+
+  public start(core: CoreStart, deps: OrgDashboardEmbedStartDeps) {}
+
+  public stop() {}
+}
+`;
+const PUBLIC_APPLICATION = `import React, { useCallback, useEffect, useRef, useState } from 'react';
+import type { MountAppArgs } from './types';
+
+type DashboardQuery = {
+  language: 'kuery' | 'lucene';
+  query: string;
+};
+
+type DashboardTimeRange = {
+  from: string;
+  to: string;
+};
+
+type SwitchDashboardMessage = {
+  type: 'ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD';
+  dashboardId: string;
+  timeRange?: DashboardTimeRange;
+  query?: DashboardQuery;
+  filters?: unknown[];
+};
+
+type ParentReadyMessage = {
+  type: 'ORG_DASHBOARD_EMBED_READY';
+  dashboardId: string | null;
+};
+
+type ParentRenderedMessage = {
+  type: 'ORG_DASHBOARD_EMBED_RENDERED';
+  dashboardId: string;
+};
+
+type ParentErrorMessage = {
+  type: 'ORG_DASHBOARD_EMBED_ERROR';
+  dashboardId: string | null;
+  message: string;
+};
+
+type ParentMessage =
+  | ParentReadyMessage
+  | ParentRenderedMessage
+  | ParentErrorMessage;
+
+const DEFAULT_ALLOWED_PARENT_ORIGINS: string[] = [
+  window.location.origin
+];
+
+function getInitialDashboardId(): string | null {
+  const params = new URLSearchParams(window.location.search);
+  return params.get('dashboardId');
+}
+
+function getAllowedParentOrigins(): string[] {
+  const params = new URLSearchParams(window.location.search);
+  const raw = params.get('parentOrigin');
+
+  if (!raw) {
+    return DEFAULT_ALLOWED_PARENT_ORIGINS;
+  }
+
+  try {
+    const decoded = decodeURIComponent(raw);
+    const origins = decoded
+      .split(',')
+      .map((origin) => origin.trim())
+      .filter(Boolean);
+
+    return origins.length > 0 ? origins : DEFAULT_ALLOWED_PARENT_ORIGINS;
+  } catch {
+    return DEFAULT_ALLOWED_PARENT_ORIGINS;
+  }
+}
+
+function isSwitchDashboardMessage(data: unknown): data is SwitchDashboardMessage {
+  if (!data || typeof data !== 'object') {
+    return false;
+  }
+
+  const message = data as Partial<SwitchDashboardMessage>;
+
+  return (
+    message.type === 'ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD' &&
+    typeof message.dashboardId === 'string' &&
+    message.dashboardId.length > 0
+  );
+}
+
+function postToParent(message: ParentMessage, targetOrigin: string) {
+  window.parent.postMessage(message, targetOrigin);
+}
+
+export function OrgDashboardEmbedApp({
+  coreStart,
+  depsStart
+}: MountAppArgs) {
+  const rootRef = useRef<HTMLDivElement | null>(null);
+  const mountedDashboardRef = useRef<any>(null);
+  const allowedParentOriginsRef = useRef<string[]>(getAllowedParentOrigins());
+  const lastParentOriginRef = useRef<string>(window.location.origin);
+
+  const [dashboardId, setDashboardId] = useState<string | null>(
+    getInitialDashboardId()
+  );
+
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    coreStart.chrome.setIsVisible(false);
+  }, [coreStart]);
+
+  const destroyCurrentDashboard = useCallback(() => {
+    if (mountedDashboardRef.current?.destroy) {
+      mountedDashboardRef.current.destroy();
+    }
+
+    mountedDashboardRef.current = null;
+
+    if (rootRef.current) {
+      rootRef.current.innerHTML = '';
+    }
+  }, []);
+
+  const applySharedDashboardState = useCallback(
+    (message: SwitchDashboardMessage) => {
+      if (message.timeRange) {
+        depsStart.data.query.timefilter.timefilter.setTime(message.timeRange);
+      }
+
+      if (message.query) {
+        depsStart.data.query.queryString.setQuery(message.query);
+      }
+
+      if (message.filters) {
+        depsStart.data.query.filterManager.setFilters(message.filters as any);
+      }
+    },
+    [depsStart.data]
+  );
+
+  useEffect(() => {
+    const onMessage = (event: MessageEvent) => {
+      if (!allowedParentOriginsRef.current.includes(event.origin)) {
+        return;
+      }
+
+      if (!isSwitchDashboardMessage(event.data)) {
+        return;
+      }
+
+      lastParentOriginRef.current = event.origin;
+
+      applySharedDashboardState(event.data);
+      setDashboardId(event.data.dashboardId);
+    };
+
+    window.addEventListener('message', onMessage);
+
+    postToParent(
+      {
+        type: 'ORG_DASHBOARD_EMBED_READY',
+        dashboardId
+      },
+      lastParentOriginRef.current
+    );
+
+    return () => window.removeEventListener('message', onMessage);
+  }, [applySharedDashboardState, dashboardId]);
+
+  useEffect(() => {
+    if (!dashboardId || !rootRef.current) {
+      return;
+    }
+
+    let cancelled = false;
+
+    async function renderDashboard() {
+      setLoading(true);
+
+      try {
+        destroyCurrentDashboard();
+
+        const factory =
+          depsStart.embeddable.getEmbeddableFactory?.('dashboard') ||
+          depsStart.embeddable.getEmbeddableFactory?.('dashboard_container');
+
+        if (!factory) {
+          throw new Error('Kibana dashboard embeddable factory was not found.');
+        }
+
+        const embeddable = await factory.create({
+          id: dashboardId,
+          savedObjectId: dashboardId,
+          viewMode: 'view',
+          hidePanelTitles: false,
+          useMargins: true,
+          syncColors: true,
+          syncCursor: true,
+          syncTooltips: true,
+          timeRange: depsStart.data.query.timefilter.timefilter.getTime(),
+          query: depsStart.data.query.queryString.getQuery(),
+          filters: depsStart.data.query.filterManager.getFilters()
+        } as any);
+
+        if (cancelled) {
+          embeddable.destroy?.();
+          return;
+        }
+
+        embeddable.render(rootRef.current!);
+        mountedDashboardRef.current = embeddable;
+
+        postToParent(
+          {
+            type: 'ORG_DASHBOARD_EMBED_RENDERED',
+            dashboardId
+          },
+          lastParentOriginRef.current
+        );
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : 'Unknown dashboard error';
+
+        if (rootRef.current) {
+          rootRef.current.innerHTML = \`
+            <div style="
+              padding: 24px;
+              font-family: sans-serif;
+              color: #bd271e;
+            ">
+              Failed to render dashboard: \${message}
+            </div>
+          \`;
+        }
+
+        postToParent(
+          {
+            type: 'ORG_DASHBOARD_EMBED_ERROR',
+            dashboardId,
+            message
+          },
+          lastParentOriginRef.current
+        );
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    }
+
+    renderDashboard();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [dashboardId, depsStart, destroyCurrentDashboard]);
+
+  useEffect(() => {
+    return () => {
+      destroyCurrentDashboard();
+    };
+  }, [destroyCurrentDashboard]);
+
+  return (
+    <div
+      style={{
+        position: 'fixed',
+        inset: 0,
+        width: '100vw',
+        height: '100vh',
+        overflow: 'hidden',
+        background: '#fff'
+      }}
+    >
+      {loading && (
+        <div
+          style={{
+            position: 'absolute',
+            inset: 0,
+            zIndex: 10,
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            fontFamily: 'sans-serif',
+            background: '#fff'
+          }}
+        >
+          Loading dashboard…
+        </div>
+      )}
+
+      <div
+        ref={rootRef}
+        style={{
+          position: 'absolute',
+          inset: 0,
+          width: '100%',
+          height: '100%'
+        }}
+      />
+    </div>
+  );
+}
+`;
+const SERVER_INDEX = `import type { PluginInitializerContext } from '@kbn/core/server';
+import { OrgDashboardEmbedServerPlugin } from './plugin';
+
+export function plugin(initializerContext: PluginInitializerContext) {
+  return new OrgDashboardEmbedServerPlugin(initializerContext);
+}
+`;
+const SERVER_PLUGIN = `import type {
+  CoreSetup,
+  CoreStart,
+  Plugin,
+  PluginInitializerContext
+} from '@kbn/core/server';
+
+export class OrgDashboardEmbedServerPlugin implements Plugin {
+  constructor(private readonly initializerContext: PluginInitializerContext) {}
+
+  public setup(core: CoreSetup) {
+    const router = core.http.createRouter();
+
+    router.get(
+      {
+        path: '/api/${KIBANA_APP_ID}/health',
+        validate: false
+      },
+      async (context, request, response) => {
+        return response.ok({
+          body: {
+            ok: true,
+            plugin: '${KIBANA_APP_ID}'
+          }
+        });
+      }
+    );
+  }
+
+  public start(core: CoreStart) {}
+
+  public stop() {}
+}
+`;
+const README = `# ${KIBANA_PLUGIN_ID}
+
+Multi-tenant, org-agnostic Kibana dashboard embed plugin.
+
+There is never space switching. Each org already lands in its own Kibana space
+through the backend proxy/session URL, and the plugin only switches dashboards
+within the current space.
+
+## Build
+
+Kibana plugins must match the exact Kibana version and must be built within the
+Kibana repo (see kbn-plugin-generator). Place this directory under
+\`kibana-extra/\` (or \`plugins/\`) and run the Kibana plugin build, e.g.:
+
+\`\`\`
+yarn build
+\`\`\`
+
+## Embed URL
+
+\`\`\`
+/kibana/app/${KIBANA_APP_ID}?dashboardId=<id>&parentOrigin=<origin>
+\`\`\`
+
+## Message protocol
+
+- Parent -> plugin: \`ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD\`
+- Plugin -> parent: \`ORG_DASHBOARD_EMBED_READY\` / \`ORG_DASHBOARD_EMBED_RENDERED\` / \`ORG_DASHBOARD_EMBED_ERROR\`
+
+Version: ${KIBANA_PLUGIN_VERSION}
+`;
+/**
+ * Returns the full set of generated plugin files for a target Kibana version.
+ *
+ * @param targetVersion - Kibana version baked into `kibana.json`.
+ */
+export function kibanaPluginFiles(targetVersion) {
+    const manifest = JSON.stringify({
+        id: KIBANA_PLUGIN_ID,
+        version: KIBANA_PLUGIN_VERSION,
+        kibanaVersion: targetVersion,
+        server: true,
+        ui: true,
+        requiredPlugins: ["dashboard", "embeddable", "data"],
+        optionalPlugins: [],
+    }, null, 2);
+    return [
+        { path: "kibana.json", content: `${manifest}\n` },
+        { path: "tsconfig.json", content: `${TS_CONFIG}\n` },
+        { path: "README.md", content: README },
+        { path: "public/types.ts", content: PUBLIC_TYPES },
+        { path: "public/index.ts", content: PUBLIC_INDEX },
+        { path: "public/plugin.tsx", content: PUBLIC_PLUGIN },
+        { path: "public/application.tsx", content: PUBLIC_APPLICATION },
+        { path: "server/index.ts", content: SERVER_INDEX },
+        { path: "server/plugin.ts", content: SERVER_PLUGIN },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../../../src/plugins/kibana/templates.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,sBAAmB;AASpF,MAAM,SAAS,GAAG;;;;CAIjB,CAAC;AAEF,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BpB,CAAC;AAEF,MAAM,YAAY,GAAG;;;;;;CAMpB,CAAC;AAEF,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;aAgBT,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzB,CAAC;AAEF,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6S1B,CAAC;AAEF,MAAM,YAAY,GAAG;;;;;;CAMpB,CAAC;AAEF,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;sBAeA,aAAa;;;;;;;uBAOZ,aAAa;;;;;;;;;;;CAWnC,CAAC;AAEF,MAAM,MAAM,GAAG,KAAK,gBAAgB;;;;;;;;;;;;;;;;;;;;;cAqBtB,aAAa;;;;;;;;WAQhB,qBAAqB;CAC/B,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,aAAqB;IACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAC7B;QACE,EAAE,EAAE,gBAAgB;QACpB,OAAO,EAAE,qBAAqB;QAC9B,aAAa,EAAE,aAAa;QAC5B,MAAM,EAAE,IAAI;QACZ,EAAE,EAAE,IAAI;QACR,eAAe,EAAE,CAAC,WAAW,EAAE,YAAY,EAAE,MAAM,CAAC;QACpD,eAAe,EAAE,EAAE;KACpB,EACD,IAAI,EACJ,CAAC,CACF,CAAC;IAEF,OAAO;QACL,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,QAAQ,IAAI,EAAE;QACjD,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,GAAG,SAAS,IAAI,EAAE;QACpD,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE;QACtC,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,YAAY,EAAE;QAClD,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,YAAY,EAAE;QAClD,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,aAAa,EAAE;QACrD,EAAE,IAAI,EAAE,wBAAwB,EAAE,OAAO,EAAE,kBAAkB,EAAE;QAC/D,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,YAAY,EAAE;QAClD,EAAE,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,aAAa,EAAE;KACrD,CAAC;AACJ,CAAC","sourcesContent":["/**\n * @module integrations/plugins/kibana/templates\n * @summary Version-parameterized source templates for the Kibana embed plugin.\n * @description Holds the generated plugin source as string templates. These\n * are materialized onto disk by the installer. The source is the reference\n * multi-tenant embed plugin preserved in DECAF-40 §8. There is never space\n * switching; the plugin is org-agnostic and the current Kibana space comes\n * from the request/session/proxy context.\n */\nimport { KIBANA_APP_ID, KIBANA_PLUGIN_ID, KIBANA_PLUGIN_VERSION } from \"./manifest\";\n\nexport interface KibanaPluginFile {\n  /** Relative path within the plugin directory. */\n  path: string;\n  /** File contents. */\n  content: string;\n}\n\nconst TS_CONFIG = `{\n  \"extends\": \"../../tsconfig.json\",\n  \"include\": [\"public/**/*\", \"server/**/*\"]\n}\n`;\n\nconst PUBLIC_TYPES = `import type {\n  AppMountParameters,\n  CoreSetup,\n  CoreStart,\n  Plugin\n} from '@kbn/core/public';\n\nimport type { DashboardStart } from '@kbn/dashboard-plugin/public';\nimport type { EmbeddableStart } from '@kbn/embeddable-plugin/public';\nimport type { DataPublicPluginStart } from '@kbn/data-plugin/public';\n\nexport interface OrgDashboardEmbedSetupDeps {}\n\nexport interface OrgDashboardEmbedStartDeps {\n  dashboard: DashboardStart;\n  embeddable: EmbeddableStart;\n  data: DataPublicPluginStart;\n}\n\nexport type OrgDashboardEmbedPlugin = Plugin<\n  void,\n  void,\n  OrgDashboardEmbedSetupDeps,\n  OrgDashboardEmbedStartDeps\n>;\n\nexport interface MountAppArgs {\n  coreStart: CoreStart;\n  depsStart: OrgDashboardEmbedStartDeps;\n  params: AppMountParameters;\n}\n`;\n\nconst PUBLIC_INDEX = `import type { OrgDashboardEmbedPlugin } from './types';\nimport { OrgDashboardEmbedPluginImpl } from './plugin';\n\nexport function plugin(): OrgDashboardEmbedPlugin {\n  return new OrgDashboardEmbedPluginImpl();\n}\n`;\n\nconst PUBLIC_PLUGIN = `import React from 'react';\nimport ReactDOM from 'react-dom';\n\nimport type { CoreSetup, CoreStart } from '@kbn/core/public';\nimport type {\n  OrgDashboardEmbedPlugin,\n  OrgDashboardEmbedSetupDeps,\n  OrgDashboardEmbedStartDeps\n} from './types';\n\nexport class OrgDashboardEmbedPluginImpl implements OrgDashboardEmbedPlugin {\n  public setup(\n    core: CoreSetup<OrgDashboardEmbedStartDeps>,\n    deps: OrgDashboardEmbedSetupDeps\n  ) {\n    core.application.register({\n      id: '${KIBANA_APP_ID}',\n      title: 'Dashboard Embed',\n      chromeless: true,\n      visibleIn: [],\n      async mount(params) {\n        const [coreStart, depsStart] = await core.getStartServices();\n        const { OrgDashboardEmbedApp } = await import('./application');\n\n        ReactDOM.render(\n          <OrgDashboardEmbedApp\n            coreStart={coreStart}\n            depsStart={depsStart}\n            params={params}\n          />,\n          params.element\n        );\n\n        return () => ReactDOM.unmountComponentAtNode(params.element);\n      }\n    });\n  }\n\n  public start(core: CoreStart, deps: OrgDashboardEmbedStartDeps) {}\n\n  public stop() {}\n}\n`;\n\nconst PUBLIC_APPLICATION = `import React, { useCallback, useEffect, useRef, useState } from 'react';\nimport type { MountAppArgs } from './types';\n\ntype DashboardQuery = {\n  language: 'kuery' | 'lucene';\n  query: string;\n};\n\ntype DashboardTimeRange = {\n  from: string;\n  to: string;\n};\n\ntype SwitchDashboardMessage = {\n  type: 'ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD';\n  dashboardId: string;\n  timeRange?: DashboardTimeRange;\n  query?: DashboardQuery;\n  filters?: unknown[];\n};\n\ntype ParentReadyMessage = {\n  type: 'ORG_DASHBOARD_EMBED_READY';\n  dashboardId: string | null;\n};\n\ntype ParentRenderedMessage = {\n  type: 'ORG_DASHBOARD_EMBED_RENDERED';\n  dashboardId: string;\n};\n\ntype ParentErrorMessage = {\n  type: 'ORG_DASHBOARD_EMBED_ERROR';\n  dashboardId: string | null;\n  message: string;\n};\n\ntype ParentMessage =\n  | ParentReadyMessage\n  | ParentRenderedMessage\n  | ParentErrorMessage;\n\nconst DEFAULT_ALLOWED_PARENT_ORIGINS: string[] = [\n  window.location.origin\n];\n\nfunction getInitialDashboardId(): string | null {\n  const params = new URLSearchParams(window.location.search);\n  return params.get('dashboardId');\n}\n\nfunction getAllowedParentOrigins(): string[] {\n  const params = new URLSearchParams(window.location.search);\n  const raw = params.get('parentOrigin');\n\n  if (!raw) {\n    return DEFAULT_ALLOWED_PARENT_ORIGINS;\n  }\n\n  try {\n    const decoded = decodeURIComponent(raw);\n    const origins = decoded\n      .split(',')\n      .map((origin) => origin.trim())\n      .filter(Boolean);\n\n    return origins.length > 0 ? origins : DEFAULT_ALLOWED_PARENT_ORIGINS;\n  } catch {\n    return DEFAULT_ALLOWED_PARENT_ORIGINS;\n  }\n}\n\nfunction isSwitchDashboardMessage(data: unknown): data is SwitchDashboardMessage {\n  if (!data || typeof data !== 'object') {\n    return false;\n  }\n\n  const message = data as Partial<SwitchDashboardMessage>;\n\n  return (\n    message.type === 'ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD' &&\n    typeof message.dashboardId === 'string' &&\n    message.dashboardId.length > 0\n  );\n}\n\nfunction postToParent(message: ParentMessage, targetOrigin: string) {\n  window.parent.postMessage(message, targetOrigin);\n}\n\nexport function OrgDashboardEmbedApp({\n  coreStart,\n  depsStart\n}: MountAppArgs) {\n  const rootRef = useRef<HTMLDivElement | null>(null);\n  const mountedDashboardRef = useRef<any>(null);\n  const allowedParentOriginsRef = useRef<string[]>(getAllowedParentOrigins());\n  const lastParentOriginRef = useRef<string>(window.location.origin);\n\n  const [dashboardId, setDashboardId] = useState<string | null>(\n    getInitialDashboardId()\n  );\n\n  const [loading, setLoading] = useState(false);\n\n  useEffect(() => {\n    coreStart.chrome.setIsVisible(false);\n  }, [coreStart]);\n\n  const destroyCurrentDashboard = useCallback(() => {\n    if (mountedDashboardRef.current?.destroy) {\n      mountedDashboardRef.current.destroy();\n    }\n\n    mountedDashboardRef.current = null;\n\n    if (rootRef.current) {\n      rootRef.current.innerHTML = '';\n    }\n  }, []);\n\n  const applySharedDashboardState = useCallback(\n    (message: SwitchDashboardMessage) => {\n      if (message.timeRange) {\n        depsStart.data.query.timefilter.timefilter.setTime(message.timeRange);\n      }\n\n      if (message.query) {\n        depsStart.data.query.queryString.setQuery(message.query);\n      }\n\n      if (message.filters) {\n        depsStart.data.query.filterManager.setFilters(message.filters as any);\n      }\n    },\n    [depsStart.data]\n  );\n\n  useEffect(() => {\n    const onMessage = (event: MessageEvent) => {\n      if (!allowedParentOriginsRef.current.includes(event.origin)) {\n        return;\n      }\n\n      if (!isSwitchDashboardMessage(event.data)) {\n        return;\n      }\n\n      lastParentOriginRef.current = event.origin;\n\n      applySharedDashboardState(event.data);\n      setDashboardId(event.data.dashboardId);\n    };\n\n    window.addEventListener('message', onMessage);\n\n    postToParent(\n      {\n        type: 'ORG_DASHBOARD_EMBED_READY',\n        dashboardId\n      },\n      lastParentOriginRef.current\n    );\n\n    return () => window.removeEventListener('message', onMessage);\n  }, [applySharedDashboardState, dashboardId]);\n\n  useEffect(() => {\n    if (!dashboardId || !rootRef.current) {\n      return;\n    }\n\n    let cancelled = false;\n\n    async function renderDashboard() {\n      setLoading(true);\n\n      try {\n        destroyCurrentDashboard();\n\n        const factory =\n          depsStart.embeddable.getEmbeddableFactory?.('dashboard') ||\n          depsStart.embeddable.getEmbeddableFactory?.('dashboard_container');\n\n        if (!factory) {\n          throw new Error('Kibana dashboard embeddable factory was not found.');\n        }\n\n        const embeddable = await factory.create({\n          id: dashboardId,\n          savedObjectId: dashboardId,\n          viewMode: 'view',\n          hidePanelTitles: false,\n          useMargins: true,\n          syncColors: true,\n          syncCursor: true,\n          syncTooltips: true,\n          timeRange: depsStart.data.query.timefilter.timefilter.getTime(),\n          query: depsStart.data.query.queryString.getQuery(),\n          filters: depsStart.data.query.filterManager.getFilters()\n        } as any);\n\n        if (cancelled) {\n          embeddable.destroy?.();\n          return;\n        }\n\n        embeddable.render(rootRef.current!);\n        mountedDashboardRef.current = embeddable;\n\n        postToParent(\n          {\n            type: 'ORG_DASHBOARD_EMBED_RENDERED',\n            dashboardId\n          },\n          lastParentOriginRef.current\n        );\n      } catch (error) {\n        const message =\n          error instanceof Error ? error.message : 'Unknown dashboard error';\n\n        if (rootRef.current) {\n          rootRef.current.innerHTML = \\`\n            <div style=\"\n              padding: 24px;\n              font-family: sans-serif;\n              color: #bd271e;\n            \">\n              Failed to render dashboard: \\${message}\n            </div>\n          \\`;\n        }\n\n        postToParent(\n          {\n            type: 'ORG_DASHBOARD_EMBED_ERROR',\n            dashboardId,\n            message\n          },\n          lastParentOriginRef.current\n        );\n      } finally {\n        if (!cancelled) {\n          setLoading(false);\n        }\n      }\n    }\n\n    renderDashboard();\n\n    return () => {\n      cancelled = true;\n    };\n  }, [dashboardId, depsStart, destroyCurrentDashboard]);\n\n  useEffect(() => {\n    return () => {\n      destroyCurrentDashboard();\n    };\n  }, [destroyCurrentDashboard]);\n\n  return (\n    <div\n      style={{\n        position: 'fixed',\n        inset: 0,\n        width: '100vw',\n        height: '100vh',\n        overflow: 'hidden',\n        background: '#fff'\n      }}\n    >\n      {loading && (\n        <div\n          style={{\n            position: 'absolute',\n            inset: 0,\n            zIndex: 10,\n            display: 'flex',\n            alignItems: 'center',\n            justifyContent: 'center',\n            fontFamily: 'sans-serif',\n            background: '#fff'\n          }}\n        >\n          Loading dashboard…\n        </div>\n      )}\n\n      <div\n        ref={rootRef}\n        style={{\n          position: 'absolute',\n          inset: 0,\n          width: '100%',\n          height: '100%'\n        }}\n      />\n    </div>\n  );\n}\n`;\n\nconst SERVER_INDEX = `import type { PluginInitializerContext } from '@kbn/core/server';\nimport { OrgDashboardEmbedServerPlugin } from './plugin';\n\nexport function plugin(initializerContext: PluginInitializerContext) {\n  return new OrgDashboardEmbedServerPlugin(initializerContext);\n}\n`;\n\nconst SERVER_PLUGIN = `import type {\n  CoreSetup,\n  CoreStart,\n  Plugin,\n  PluginInitializerContext\n} from '@kbn/core/server';\n\nexport class OrgDashboardEmbedServerPlugin implements Plugin {\n  constructor(private readonly initializerContext: PluginInitializerContext) {}\n\n  public setup(core: CoreSetup) {\n    const router = core.http.createRouter();\n\n    router.get(\n      {\n        path: '/api/${KIBANA_APP_ID}/health',\n        validate: false\n      },\n      async (context, request, response) => {\n        return response.ok({\n          body: {\n            ok: true,\n            plugin: '${KIBANA_APP_ID}'\n          }\n        });\n      }\n    );\n  }\n\n  public start(core: CoreStart) {}\n\n  public stop() {}\n}\n`;\n\nconst README = `# ${KIBANA_PLUGIN_ID}\n\nMulti-tenant, org-agnostic Kibana dashboard embed plugin.\n\nThere is never space switching. Each org already lands in its own Kibana space\nthrough the backend proxy/session URL, and the plugin only switches dashboards\nwithin the current space.\n\n## Build\n\nKibana plugins must match the exact Kibana version and must be built within the\nKibana repo (see kbn-plugin-generator). Place this directory under\n\\`kibana-extra/\\` (or \\`plugins/\\`) and run the Kibana plugin build, e.g.:\n\n\\`\\`\\`\nyarn build\n\\`\\`\\`\n\n## Embed URL\n\n\\`\\`\\`\n/kibana/app/${KIBANA_APP_ID}?dashboardId=<id>&parentOrigin=<origin>\n\\`\\`\\`\n\n## Message protocol\n\n- Parent -> plugin: \\`ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD\\`\n- Plugin -> parent: \\`ORG_DASHBOARD_EMBED_READY\\` / \\`ORG_DASHBOARD_EMBED_RENDERED\\` / \\`ORG_DASHBOARD_EMBED_ERROR\\`\n\nVersion: ${KIBANA_PLUGIN_VERSION}\n`;\n\n/**\n * Returns the full set of generated plugin files for a target Kibana version.\n *\n * @param targetVersion - Kibana version baked into `kibana.json`.\n */\nexport function kibanaPluginFiles(targetVersion: string): KibanaPluginFile[] {\n  const manifest = JSON.stringify(\n    {\n      id: KIBANA_PLUGIN_ID,\n      version: KIBANA_PLUGIN_VERSION,\n      kibanaVersion: targetVersion,\n      server: true,\n      ui: true,\n      requiredPlugins: [\"dashboard\", \"embeddable\", \"data\"],\n      optionalPlugins: [],\n    },\n    null,\n    2\n  );\n\n  return [\n    { path: \"kibana.json\", content: `${manifest}\\n` },\n    { path: \"tsconfig.json\", content: `${TS_CONFIG}\\n` },\n    { path: \"README.md\", content: README },\n    { path: \"public/types.ts\", content: PUBLIC_TYPES },\n    { path: \"public/index.ts\", content: PUBLIC_INDEX },\n    { path: \"public/plugin.tsx\", content: PUBLIC_PLUGIN },\n    { path: \"public/application.tsx\", content: PUBLIC_APPLICATION },\n    { path: \"server/index.ts\", content: SERVER_INDEX },\n    { path: \"server/plugin.ts\", content: SERVER_PLUGIN },\n  ];\n}\n"]}

package/lib/esm/plugins/kibana/types.js

@@ -0,0 +1,10 @@
+/**
+ * @module integrations/plugins/kibana/types
+ * @summary Kibana embed plugin types.
+ * @description Re-exports the shared contract types and exposes Kibana-specific
+ * constants/types for the org-agnostic dashboard embed plugin.
+ */
+export * from "./../contract.js";
+export { KIBANA_PLUGIN_ID, KIBANA_APP_ID, KIBANA_PLUGIN_VERSION, buildKibanaManifest, } from "./manifest.js";
+export { kibanaPluginFiles } from "./templates.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGx1Z2lucy9raWJhbmEvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxpQ0FBNEI7QUFDNUIsT0FBTyxFQUNMLGdCQUFnQixFQUNoQixhQUFhLEVBQ2IscUJBQXFCLEVBQ3JCLG1CQUFtQixHQUVwQixzQkFBbUI7QUFDcEIsT0FBTyxFQUFFLGlCQUFpQixFQUF5Qix1QkFBb0IiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL3BsdWdpbnMva2liYW5hL3R5cGVzXG4gKiBAc3VtbWFyeSBLaWJhbmEgZW1iZWQgcGx1Z2luIHR5cGVzLlxuICogQGRlc2NyaXB0aW9uIFJlLWV4cG9ydHMgdGhlIHNoYXJlZCBjb250cmFjdCB0eXBlcyBhbmQgZXhwb3NlcyBLaWJhbmEtc3BlY2lmaWNcbiAqIGNvbnN0YW50cy90eXBlcyBmb3IgdGhlIG9yZy1hZ25vc3RpYyBkYXNoYm9hcmQgZW1iZWQgcGx1Z2luLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi4vY29udHJhY3RcIjtcbmV4cG9ydCB7XG4gIEtJQkFOQV9QTFVHSU5fSUQsXG4gIEtJQkFOQV9BUFBfSUQsXG4gIEtJQkFOQV9QTFVHSU5fVkVSU0lPTixcbiAgYnVpbGRLaWJhbmFNYW5pZmVzdCxcbiAgdHlwZSBLaWJhbmFNYW5pZmVzdCxcbn0gZnJvbSBcIi4vbWFuaWZlc3RcIjtcbmV4cG9ydCB7IGtpYmFuYVBsdWdpbkZpbGVzLCB0eXBlIEtpYmFuYVBsdWdpbkZpbGUgfSBmcm9tIFwiLi90ZW1wbGF0ZXNcIjtcbiJdfQ==

package/lib/esm/plugins/superset/host.js

@@ -0,0 +1,21 @@
+/**
+ * @module integrations/plugins/superset/host
+ * @summary Angular host-side helpers for the Superset embed plugin.
+ * @description DOM-free convenience helpers the Angular host uses to build the
+ * embedded URL and send switch-dashboard messages to the embedded Superset
+ * plugin via the SDK handle.
+ */
+import { sendSwitchDashboardMessage as sendShared, } from "./../contract.js";
+import { buildSupersetEmbedUrl } from "./installer.js";
+export { buildSupersetEmbedUrl };
+/**
+ * Send a switch-dashboard message to the embedded Superset dashboard.
+ *
+ * The Angular host passes the embedded SDK's `EmbeddedDashboard` handle
+ * (wrapped to satisfy `EmbedMessageTarget.switchDashboard`) and the Superset
+ * origin as `targetOrigin`.
+ */
+export function sendSupersetSwitchDashboardMessage(target, payload, targetOrigin) {
+    sendShared(target, payload, targetOrigin);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/plugins/superset/index.js

@@ -0,0 +1,16 @@
+/**
+ * @module integrations/plugins/superset
+ * @summary Superset dashboard embed plugin surface.
+ * @description Org-agnostic multi-tenant Superset dashboard embed plugin
+ * (patch-and-build strategy). Same API as the Kibana plugin. Decaf holds
+ * patch scripts that modify Superset's internal embedded frontend and SDK
+ * source files to add a `switchDashboard` method, keeping the iframe element,
+ * document, contentWindow, React runtime, and Switchboard MessageChannel alive.
+ */
+export * from "./../contract.js";
+export * from "./types.js";
+export * from "./manifest.js";
+export * from "./templates.js";
+export { SupersetDashboardEmbedPlugin, supersetDashboardEmbedPlugin, createSupersetDashboardEmbedPlugin, buildSupersetEmbedUrl, SUPERSET_DEFAULT_BASE_PATH, } from "./installer.js";
+export { sendSupersetSwitchDashboardMessage, } from "./host.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGx1Z2lucy9zdXBlcnNldC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRztBQUNILGlDQUE0QjtBQUM1QiwyQkFBd0I7QUFDeEIsOEJBQTJCO0FBQzNCLCtCQUE0QjtBQUM1QixPQUFPLEVBQ0wsNEJBQTRCLEVBQzVCLDRCQUE0QixFQUM1QixrQ0FBa0MsRUFDbEMscUJBQXFCLEVBQ3JCLDBCQUEwQixHQUUzQix1QkFBb0I7QUFDckIsT0FBTyxFQUNMLGtDQUFrQyxHQUNuQyxrQkFBZSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvcGx1Z2lucy9zdXBlcnNldFxuICogQHN1bW1hcnkgU3VwZXJzZXQgZGFzaGJvYXJkIGVtYmVkIHBsdWdpbiBzdXJmYWNlLlxuICogQGRlc2NyaXB0aW9uIE9yZy1hZ25vc3RpYyBtdWx0aS10ZW5hbnQgU3VwZXJzZXQgZGFzaGJvYXJkIGVtYmVkIHBsdWdpblxuICogKHBhdGNoLWFuZC1idWlsZCBzdHJhdGVneSkuIFNhbWUgQVBJIGFzIHRoZSBLaWJhbmEgcGx1Z2luLiBEZWNhZiBob2xkc1xuICogcGF0Y2ggc2NyaXB0cyB0aGF0IG1vZGlmeSBTdXBlcnNldCdzIGludGVybmFsIGVtYmVkZGVkIGZyb250ZW5kIGFuZCBTREtcbiAqIHNvdXJjZSBmaWxlcyB0byBhZGQgYSBgc3dpdGNoRGFzaGJvYXJkYCBtZXRob2QsIGtlZXBpbmcgdGhlIGlmcmFtZSBlbGVtZW50LFxuICogZG9jdW1lbnQsIGNvbnRlbnRXaW5kb3csIFJlYWN0IHJ1bnRpbWUsIGFuZCBTd2l0Y2hib2FyZCBNZXNzYWdlQ2hhbm5lbCBhbGl2ZS5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4uL2NvbnRyYWN0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbWFuaWZlc3RcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RlbXBsYXRlc1wiO1xuZXhwb3J0IHtcbiAgU3VwZXJzZXREYXNoYm9hcmRFbWJlZFBsdWdpbixcbiAgc3VwZXJzZXREYXNoYm9hcmRFbWJlZFBsdWdpbixcbiAgY3JlYXRlU3VwZXJzZXREYXNoYm9hcmRFbWJlZFBsdWdpbixcbiAgYnVpbGRTdXBlcnNldEVtYmVkVXJsLFxuICBTVVBFUlNFVF9ERUZBVUxUX0JBU0VfUEFUSCxcbiAgdHlwZSBTdXBlcnNldEluc3RhbGxPcHRpb25zLFxufSBmcm9tIFwiLi9pbnN0YWxsZXJcIjtcbmV4cG9ydCB7XG4gIHNlbmRTdXBlcnNldFN3aXRjaERhc2hib2FyZE1lc3NhZ2UsXG59IGZyb20gXCIuL2hvc3RcIjtcbiJdfQ==