@manta-eu/horns-client 0.1.0 → 0.1.1

package/dist/lib/surface/declarations.js

@@ -0,0 +1,77 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { moduleOfExport, sdkModules, surfaceExports } from "@manta-eu/horns/render";
+/** Above this an entry is a type tree nobody can read, and the walk stopped somewhere it should not have. */
+const maxEntryChars = 6000;
+/** Node only: `import.meta.resolve` is unavailable under vitest's transform, so a test passes its own root. */
+export function sdkDistRoot() {
+    return join(dirname(dirname(fileURLToPath(import.meta.resolve("@manta-eu/react")))), "dist");
+}
+function declarationFilesIn(directory) {
+    return readdirSync(directory).flatMap((entry) => {
+        const path = join(directory, entry);
+        if (statSync(path).isDirectory())
+            return declarationFilesIn(path);
+        return path.endsWith(".d.ts") ? [path] : [];
+    });
+}
+/** A declaration and its body, from `export …` to the `;` that closes it. */
+function blockOf(texts, name) {
+    const pattern = new RegExp(`^export (?:declare (?:const|function|class)|type|interface) ${name}\\b`, "m");
+    for (const text of texts) {
+        const start = text.search(pattern);
+        if (start < 0)
+            continue;
+        let depth = 0;
+        for (let at = start; at < text.length; at += 1) {
+            const character = text[at];
+            if (character === "{")
+                depth += 1;
+            else if (character === "}")
+                depth -= 1;
+            else if (character === ";" && depth === 0)
+                return text.slice(start, at + 1);
+        }
+        return text.slice(start);
+    }
+    return undefined;
+}
+/**
+ * The export's declaration plus the ones it names, transitively.
+ *
+ * A props type sits beside its component and may name a schema elsewhere — `BarChartProps` reaches
+ * `BarChartData` reaches `barChartSchema`. Following the names keeps the answer to what the export is,
+ * where a whole directory would hand over every chart in the design system.
+ */
+function scopeOf(texts, name, hops) {
+    const first = blockOf(texts, name);
+    if (first === undefined)
+        return undefined;
+    const seen = new Set([name]);
+    const blocks = [first];
+    for (let hop = 0; hop < hops; hop += 1) {
+        const named = [...blocks.join("\n").matchAll(/\b([A-Za-z_$][\w$]*)\b/g)].flatMap((match) => match[1] ?? []);
+        for (const referenced of named) {
+            if (seen.has(referenced))
+                continue;
+            seen.add(referenced);
+            const block = blockOf(texts, referenced);
+            if (block !== undefined)
+                blocks.push(block);
+        }
+    }
+    return blocks.join("\n");
+}
+export function componentApiFrom(root, hops = 3) {
+    const texts = declarationFilesIn(root).map((path) => readFileSync(path, "utf8"));
+    // Only the design system's own: React's hooks and the kit's plan module are not its to declare.
+    const names = [...new Set(sdkModules.flatMap((module) => [...(surfaceExports(module) ?? [])]))].sort();
+    return Object.freeze(Object.fromEntries(names.flatMap((name) => {
+        const scope = scopeOf(texts, name, hops);
+        if (scope === undefined || scope.length > maxEntryChars)
+            return [];
+        const from = moduleOfExport(name);
+        return [[name, `// ${name}, from "${from ?? "@manta-eu/react"}"\n${scope}`]];
+    })));
+}

package/dist/lib/written-surface.js

@@ -1,10 +1,21 @@
 import { useCallback, useId, useMemo, useState } from "react";
+import { viewPowersModule } from "@manta-eu/horns/render";
 // The whole barrel, because a view may reach for any of it; `createSurfaceLoader` narrows it to the declared
 // exports before the view sees it. Dynamic, and held at module scope: `WrittenView` recompiles whenever this
 // identity changes.
 export const loadWrittenSurface = async () => {
-    const [react, chart] = await Promise.all([import("@manta-eu/react"), import("@manta-eu/react/chart")]);
-    return { "@manta-eu/react": react, "@manta-eu/react/chart": chart };
+    const [react, chart, plan, explain] = await Promise.all([
+        import("@manta-eu/react"),
+        import("@manta-eu/react/chart"),
+        import("@manta-eu/horns-kit/plan"),
+        import("@manta-eu/horns-kit/view"),
+    ]);
+    return {
+        "@manta-eu/react": react,
+        "@manta-eu/react/chart": chart,
+        "@manta-eu/horns-kit/plan": plan,
+        [viewPowersModule]: explain,
+    };
 };
 // This app's React, so a view's state lives in the same reconciler as the page rather than in a second copy.
 export const writtenHooks = { useState, useMemo, useCallback, useId };

package/dist/standalone/app.d.ts

@@ -0,0 +1,2 @@
+/** The session gate, for a Horns that is the whole page. A host that has already gated mounts none of it. */
+export declare function HornsApp(): import("react").JSX.Element;

package/dist/standalone/app.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAuth } from "@manta-eu/react/hooks/useAuth";
+import { AuthContext } from "@manta-eu/react/providers/AuthContext";
+import { useActiveDatastore } from "@manta-eu/react/providers";
+import { isPresent } from "@manta-eu/lib/present";
+import { signedInParam } from "@manta-eu/horns-server/shared";
+import { AppRoutes } from "../app/routes";
+import { Centered, SignIn, SignInLooped } from "./gates";
+import { DatastoreMissing } from "../components/states";
+import { useCustomerDatastoresQuery } from "@manta-eu/client";
+import { useMantaClient } from "@manta-eu/react/providers";
+// Horns' `/login` stamps this, so a return carrying it with no session is a round trip that did not
+// complete rather than a visitor who has not tried. `useAuth` has no equivalent and its generic path loops.
+const justSignedIn = () => new URLSearchParams(window.location.search).get(signedInParam) === "1";
+// Keycloak hands a failure back on the URL. `useAuth` cannot see it, and without this the page offers
+// "sign in" again to someone whose sign-in just failed.
+const authError = () => new URLSearchParams(window.location.search).get("auth_error") ?? undefined;
+/** The session gate, for a Horns that is the whole page. A host that has already gated mounts none of it. */
+export function HornsApp() {
+    const auth = useAuth();
+    const { datastoreId } = useActiveDatastore();
+    const { mantaClient } = useMantaClient();
+    // `sessionContext` lists the datastores a member belongs to, which for an operator is none.
+    const customers = useCustomerDatastoresQuery(mantaClient, undefined, { enabled: auth.isOperator });
+    const datastores = auth.isOperator ? (customers.data?.customerDatastores ?? []) : auth.datastores;
+    const failed = authError();
+    if (isPresent(failed))
+        return _jsx(Centered, { role: "alert", children: failed });
+    if (auth.isLoading)
+        return _jsx(Centered, { children: "Loading\u2026" });
+    if (isPresent(auth.error))
+        return _jsx(Centered, { role: "alert", children: auth.error });
+    if (!auth.isSessionValid)
+        return justSignedIn() ? _jsx(SignInLooped, {}) : _jsx(SignIn, {});
+    if (auth.contextFailed)
+        return _jsx(Centered, { role: "alert", children: "Could not load your account. Try again." });
+    if (!isPresent(auth.user))
+        return _jsx(Centered, { children: "Loading\u2026" });
+    // Refused here rather than left to a page to render empty, in the words every page already used.
+    if (isPresent(datastoreId) && !auth.datastoreAccessGranted) {
+        return (_jsx("main", { className: "grid min-h-screen place-items-center p-8", children: _jsx(DatastoreMissing, {}) }));
+    }
+    return (_jsx(AuthContext.Provider, { value: {
+            user: auth.user,
+            datastore: auth.datastore,
+            datastores,
+            logout: auth.logout,
+            isOperator: auth.isOperator,
+            canManageTeam: auth.canManageTeam,
+            canManageIntegrations: auth.canManageIntegrations,
+            canManageStreams: auth.canManageStreams,
+            canManageSharedMemories: auth.canManageSharedMemories,
+            canSwitchDatastore: auth.canSwitchDatastore,
+            allowedModels: auth.allowedModels,
+            orgRoles: auth.orgRoles,
+        }, children: _jsx(AppRoutes, {}) }));
+}

package/dist/standalone/client.d.ts

@@ -0,0 +1,15 @@
+import { type ShapeCatalogSource } from "../lib/shapes/catalog";
+import "../app/globals.css";
+export type MountHornsOptions = {
+    /** The realm's shapes. Horns ships none: they describe a deployment's data model, not the library's. */
+    shapes: ShapeCatalogSource;
+    /** Defaults to `#app`, which is what this package's own document declares. */
+    container?: HTMLElement;
+};
+/**
+ * Mount Horns as a whole page. A host with a router of its own splices `hornsRoutes()` in instead.
+ *
+ * The base URL is this deployment's origin, never agents': the browser holds this worker's session cookies
+ * and none of agents', so every SDK call has to land here to be proxied with them.
+ */
+export declare function mountHorns({ shapes, container }: MountHornsOptions): void;

package/dist/{client.js → standalone/client.js}

@@ -1,22 +1,26 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
-import { BrowserRouter } from "react-router";
 import { ErrorBoundary } from "@sentry/react";
-import { AppRoutes } from "./app/routes";
-import { MantaSessionProvider } from "./lib/manta/session";
-import { provideShapeCatalog } from "./lib/shapes/catalog";
-import { initSentry } from "./lib/telemetry/sentry";
-import "./app/globals.css";
+import { Providers } from "@manta-eu/react/providers";
+import { provideShapeCatalog } from "../lib/shapes/catalog";
+import { initSentry } from "../lib/telemetry/sentry";
+import { HornsApp } from "./app";
+import "../app/globals.css";
 function AppCrashed() {
     return (_jsx("main", { className: "grid min-h-screen place-items-center p-8 text-center", children: _jsxs("div", { children: [_jsx("h1", { className: "text-xl font-semibold", children: "Something went wrong" }), _jsx("p", { className: "mt-2 text-sm opacity-70", children: "Reload the page to try again." })] }) }));
 }
-/** Mount Horns as a whole page. A host with a router of its own splices `hornsRoutes()` in instead. */
+/**
+ * Mount Horns as a whole page. A host with a router of its own splices `hornsRoutes()` in instead.
+ *
+ * The base URL is this deployment's origin, never agents': the browser holds this worker's session cookies
+ * and none of agents', so every SDK call has to land here to be proxied with them.
+ */
 export function mountHorns({ shapes, container }) {
     provideShapeCatalog(shapes);
     initSentry();
     const root = container ?? document.getElementById("app");
     if (!root)
         throw new Error("mountHorns found no container: pass one, or give the document an #app element.");
-    createRoot(root).render(_jsx(StrictMode, { children: _jsx(ErrorBoundary, { fallback: _jsx(AppCrashed, {}), children: _jsx(BrowserRouter, { children: _jsx(MantaSessionProvider, { children: _jsx(AppRoutes, {}) }) }) }) }));
+    createRoot(root).render(_jsx(StrictMode, { children: _jsx(ErrorBoundary, { fallback: _jsx(AppCrashed, {}), children: _jsx(Providers, { mantaBaseUrl: window.location.origin, children: _jsx(HornsApp, {}) }) }) }));
 }

package/dist/standalone/gates.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+type CenteredProps = {
+    children: ReactNode;
+    role?: "alert";
+};
+export declare function Centered({ children, role }: CenteredProps): import("react").JSX.Element;
+export declare function SignIn(): import("react").JSX.Element;
+/** A return from Keycloak carrying the marker but no session: the round trip did not complete. */
+export declare function SignInLooped(): import("react").JSX.Element;
+export {};

package/dist/standalone/gates.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { signInHref } from "../lib/manta/sign-in";
+export function Centered({ children, role }) {
+    return (_jsx("main", { className: "grid min-h-screen place-items-center p-8 text-center", children: _jsx("p", { className: "text-sm opacity-70", ...(role ? { role } : {}), children: children }) }));
+}
+function signIn() {
+    return signInHref(`${window.location.pathname}${window.location.search}`);
+}
+export function SignIn() {
+    return (_jsx("main", { className: "grid min-h-screen place-items-center p-8 text-center", children: _jsxs("div", { className: "flex flex-col items-center gap-4", children: [_jsx("h1", { className: "text-xl font-semibold", children: "Sign in to Manta Horns" }), _jsx("a", { className: "rounded-md border px-4 py-2", href: signIn(), children: "Sign in" })] }) }));
+}
+/** A return from Keycloak carrying the marker but no session: the round trip did not complete. */
+export function SignInLooped() {
+    return (_jsx("main", { className: "grid min-h-screen place-items-center p-8 text-center", children: _jsxs("div", { className: "flex flex-col items-center gap-4", children: [_jsx("p", { role: "alert", children: "Signing in did not complete. Try again, or ask an admin to check your access." }), _jsx("a", { className: "rounded-md border px-4 py-2", href: signIn(), children: "Sign in" })] }) }));
+}