@manta-eu/horns-kit 0.1.0

package/dist/shape-views/google.json

@@ -0,0 +1,22 @@
+[
+    {
+        "schema": "GoogleCampaignSchema",
+        "classCurie": "google:Campaign",
+        "status": "curated",
+        "fields": [
+            { "name": "campaignName", "path": "google:campaignName", "type": "string" },
+            { "name": "campaignAdvertisingChannelType", "path": "google:campaignAdvertisingChannelType", "type": "string" },
+            { "name": "campaignStatus", "path": "google:campaignStatus", "type": "string" },
+            { "name": "campaignBiddingStrategyType", "path": "google:campaignBiddingStrategyType", "type": "string" },
+            { "name": "campaignStartDate", "path": "google:campaignStartDate", "type": "date" },
+            { "name": "campaignOptimizationScore", "path": "google:campaignOptimizationScore", "type": "number" }
+        ],
+        "record": {
+            "type": "record",
+            "title": "campaignName",
+            "subtitle": "campaignAdvertisingChannelType",
+            "fields": ["campaignBiddingStrategyType", "campaignStartDate", "campaignOptimizationScore"],
+            "badges": ["campaignStatus"]
+        }
+    }
+]

package/dist/shape-views/index.d.ts

@@ -0,0 +1,2 @@
+import { type ShapeViewSpec } from "@manta-eu/horns/shapes";
+export declare const shapeViewSpecs: readonly ShapeViewSpec[];

package/dist/shape-views/index.js

@@ -0,0 +1,13 @@
+import { shapeViewSpecSchema } from "@manta-eu/horns/shapes";
+import attio from "./attio.json" with { type: "json" };
+import coresignal from "./coresignal.json" with { type: "json" };
+import generated from "./generated.json" with { type: "json" };
+import google from "./google.json" with { type: "json" };
+import linkedin from "./linkedin.json" with { type: "json" };
+import meta from "./meta.json" with { type: "json" };
+import slack from "./slack.json" with { type: "json" };
+// The HornViews the kit ships for LDKit shapes, one file per namespace. Coverage work adds to these, and
+// `apps/web` checks every one against the SDK's live shapes.
+export const shapeViewSpecs = shapeViewSpecSchema
+    .array()
+    .parse([...attio, ...coresignal, ...generated, ...google, ...linkedin, ...meta, ...slack]);

package/dist/shape-views/linkedin.json

@@ -0,0 +1,23 @@
+[
+    {
+        "schema": "LinkedinAdAccountSchema",
+        "classCurie": "linkedin:AdAccount",
+        "status": "drafted",
+        "fields": [
+            { "name": "name", "path": "schema:name", "type": "string" },
+            { "name": "type", "path": "linkedin:type", "type": "string" },
+            { "name": "status", "path": "linkedin:status", "type": "string" },
+            { "name": "currency", "path": "schema:currency", "type": "string" },
+            { "name": "totalBudgetAmount", "path": "linkedin:totalBudgetAmount", "type": "number" },
+            { "name": "dateCreated", "path": "schema:dateCreated", "type": "date" },
+            { "name": "test", "path": "linkedin:test", "type": "boolean" }
+        ],
+        "record": {
+            "type": "record",
+            "title": "name",
+            "subtitle": "type",
+            "fields": ["currency", "totalBudgetAmount", "dateCreated", "test"],
+            "badges": ["status"]
+        }
+    }
+]

package/dist/shape-views/meta.json

@@ -0,0 +1,19 @@
+[
+    {
+        "schema": "MetaAdSchema",
+        "classCurie": "meta:Ad",
+        "status": "curated",
+        "fields": [
+            { "name": "label", "path": "rdfs:label", "type": "string" },
+            { "name": "effectiveStatus", "path": "meta:effectiveStatus", "type": "string" },
+            { "name": "identifier", "path": "schema:identifier", "type": "string" },
+            { "name": "dateCreated", "path": "schema:dateCreated", "type": "date" }
+        ],
+        "record": {
+            "type": "record",
+            "title": "label",
+            "fields": ["dateCreated", "identifier"],
+            "badges": ["effectiveStatus"]
+        }
+    }
+]

package/dist/shape-views/slack.json

@@ -0,0 +1,12 @@
+[
+    {
+        "schema": "SlackWorkspaceSchema",
+        "classCurie": "slack:Workspace",
+        "status": "curated",
+        "fields": [
+            { "name": "name", "path": "schema:name", "type": "string" },
+            { "name": "identifier", "path": "schema:identifier", "type": "string" }
+        ],
+        "record": { "type": "record", "title": "name", "fields": ["identifier"] }
+    }
+]

package/dist/written/index.d.ts

@@ -0,0 +1,2 @@
+export { compileWritten, createSurfaceLoader, evaluateWritten, transpileWritten, WrittenViewError, type CompileWrittenOptions, type WrittenComponent, type WrittenComponentProps, type WrittenLink, type WrittenSurface, } from "./runtime.ts";
+export { WrittenView, type WrittenViewProps } from "./written-view.tsx";

package/dist/written/index.js

@@ -0,0 +1,4 @@
+// Off the package barrel on purpose: the only part of the kit carrying a transpiler, so a host that shows no
+// written view never loads it.
+export { compileWritten, createSurfaceLoader, evaluateWritten, transpileWritten, WrittenViewError, } from "./runtime.js";
+export { WrittenView } from "./written-view.js";

package/dist/written/runtime.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from "react";
+/** A module the host binds by specifier: `{ "@manta-eu/react": mod, "@manta-eu/react/chart": mod }`. */
+export type WrittenSurface = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+export declare class WrittenViewError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Serves the surface and nothing else, narrowed to the declared exports so a host cannot widen it. */
+export declare function createSurfaceLoader(surface: WrittenSurface, hooks: Readonly<Record<string, unknown>>): (specifier: string) => Readonly<Record<string, unknown>>;
+/** TSX to CommonJS. Loaded on first use: a Horn with no written view must not pay for the transpiler. */
+export declare function transpileWritten(source: string): Promise<string>;
+/** Where an IRI opens, and what the link says. The host builds the href; a view never composes one. */
+export type WrittenLink = {
+    href: string;
+    label: string;
+};
+export type WrittenComponentProps = {
+    rows: readonly Readonly<Record<string, unknown>>[];
+    columns: readonly string[];
+    /** The display name of every IRI in the rows, so a view shows a thing rather than an address. */
+    labels: Readonly<Record<string, string>>;
+    /** Where each IRI opens, for the ones that have a page. Absent means there is nothing to link to. */
+    links: Readonly<Record<string, WrittenLink>>;
+};
+export type WrittenComponent = (props: WrittenComponentProps) => ReactNode;
+/** `new Function` rather than an import: by now the source is CommonJS, and its only way out is `require`. */
+export declare function evaluateWritten(code: string, load: (specifier: string) => Readonly<Record<string, unknown>>): WrittenComponent;
+export type CompileWrittenOptions = {
+    source: string;
+    /**
+     * Fetches the host's surface, on demand.
+     *
+     * A function rather than the modules themselves so that binding the whole design system costs nothing on a
+     * page with no written view — which is every page, most of the time. The host's loader is where the dynamic
+     * import lives, so the bundler can split it out.
+     */
+    loadSurface: () => Promise<WrittenSurface>;
+    /** React's own hooks, from the host's React, so a view's state lives in the same reconciler as the page. */
+    hooks: Readonly<Record<string, unknown>>;
+};
+/** Source to a component, ready to render in the host's own tree. */
+export declare function compileWritten(options: CompileWrittenOptions): Promise<WrittenComponent>;

package/dist/written/runtime.js

@@ -0,0 +1,83 @@
+import { createElement, Fragment } from "react";
+import { allowedReactHooks, isSurfaceModule, surfaceExports } from "@manta-eu/horns/render";
+export class WrittenViewError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "WrittenViewError";
+    }
+}
+// The JSX the transpiler emits calls `React.createElement`, and the classic runtime needs `Fragment` for
+// `<>`. Neither is importable — `allowedReactHooks` is what the model may name — so they are injected rather
+// than served, and a source that imports them is refused upstream.
+const reactModule = {
+    createElement,
+    Fragment,
+};
+/** Serves the surface and nothing else, narrowed to the declared exports so a host cannot widen it. */
+export function createSurfaceLoader(surface, hooks) {
+    const bound = new Map();
+    for (const [specifier, module] of Object.entries(surface)) {
+        const allowed = surfaceExports(specifier);
+        if (allowed === undefined)
+            continue;
+        bound.set(specifier, Object.fromEntries([...allowed].flatMap((name) => (name in module ? [[name, module[name]]] : []))));
+    }
+    bound.set("react", {
+        ...reactModule,
+        ...Object.fromEntries(allowedReactHooks.flatMap((name) => (name in hooks ? [[name, hooks[name]]] : []))),
+    });
+    return (specifier) => {
+        const module = bound.get(specifier);
+        if (module === undefined) {
+            throw new WrittenViewError(isSurfaceModule(specifier)
+                ? `The host did not bind "${specifier}", which this view imports.`
+                : `"${specifier}" is not on the view surface.`);
+        }
+        return module;
+    };
+}
+let transpiler;
+/** TSX to CommonJS. Loaded on first use: a Horn with no written view must not pay for the transpiler. */
+export async function transpileWritten(source) {
+    transpiler ??= (await import("sucrase")).transform;
+    try {
+        return transpiler(source, {
+            transforms: ["typescript", "jsx", "imports"],
+            jsxRuntime: "classic",
+            production: true,
+        }).code;
+    }
+    catch (cause) {
+        throw new WrittenViewError(`This view does not compile: ${cause instanceof Error ? cause.message : "unknown"}`, {
+            cause,
+        });
+    }
+}
+function isCallable(value) {
+    return typeof value === "function";
+}
+/** `new Function` rather than an import: by now the source is CommonJS, and its only way out is `require`. */
+export function evaluateWritten(code, load) {
+    const moduleRecord = { exports: {} };
+    try {
+        const factory = new Function("require", "exports", "module", "React", code);
+        factory(load, moduleRecord.exports, moduleRecord, reactModule);
+    }
+    catch (cause) {
+        if (cause instanceof WrittenViewError)
+            throw cause;
+        throw new WrittenViewError(`This view failed while loading: ${cause instanceof Error ? cause.message : "unknown"}`, {
+            cause,
+        });
+    }
+    const component = moduleRecord.exports["default"];
+    if (!isCallable(component)) {
+        throw new WrittenViewError("This view exports no component. A written view is one `export default`.");
+    }
+    return component;
+}
+/** Source to a component, ready to render in the host's own tree. */
+export async function compileWritten(options) {
+    const [code, surface] = await Promise.all([transpileWritten(options.source), options.loadSurface()]);
+    return evaluateWritten(code, createSurfaceLoader(surface, options.hooks));
+}

package/dist/written/written-view.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from "react";
+import { type WrittenLink, type WrittenSurface } from "./runtime.ts";
+export type WrittenViewProps = {
+    /** The TSX the Studio wrote. Refused by `tsxViolations` long before it reaches here. */
+    source: string;
+    rows: readonly Readonly<Record<string, unknown>>[];
+    columns: readonly string[];
+    /** The snapshot's names by IRI, so a view can show the thing an IRI points at. */
+    labels: Readonly<Record<string, string>>;
+    /** Where each IRI opens, for the ones with a page. The host composes the href; the view never does. */
+    links: Readonly<Record<string, WrittenLink>>;
+    /**
+     * Fetches the host's own modules, by specifier, narrowed to the declared surface before the view sees
+     * them. Hold this at module scope: a fresh function every render recompiles the view every render.
+     */
+    loadSurface: () => Promise<WrittenSurface>;
+    /** The host's React hooks, so a view's state lives in the same reconciler as the page. Also stable. */
+    hooks: Readonly<Record<string, unknown>>;
+    /** Drawn while the transpiler loads. */
+    fallback?: ReactNode;
+    renderError?: (message: string) => ReactNode;
+};
+export declare function WrittenView(props: WrittenViewProps): ReactNode;

package/dist/written/written-view.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Component, useEffect, useState } from "react";
+import { compileWritten, WrittenViewError, } from "./runtime.js";
+// Keyed on the source, so fixing a view brings it back without a reload.
+class WrittenBoundary extends Component {
+    state = {};
+    static getDerivedStateFromError(error) {
+        return { message: error instanceof Error ? error.message : "unknown error" };
+    }
+    render() {
+        const { message } = this.state;
+        return message === undefined ? this.props.children : this.props.render(message);
+    }
+}
+const defaultError = (message) => (_jsx("p", { role: "alert", style: { margin: 0, fontSize: 14 }, children: message }));
+export function WrittenView(props) {
+    const { source, rows, columns, labels, links, loadSurface, hooks, fallback, renderError = defaultError } = props;
+    const [state, setState] = useState({});
+    useEffect(() => {
+        let live = true;
+        setState({});
+        compileWritten({ source, loadSurface, hooks })
+            .then((component) => {
+            if (live)
+                setState({ component });
+        })
+            .catch((cause) => {
+            if (!live)
+                return;
+            // A WrittenViewError already says what a person can act on; anything else is a bug in the runtime.
+            setState({
+                error: cause instanceof WrittenViewError
+                    ? cause.message
+                    : `This view could not be prepared: ${cause instanceof Error ? cause.message : "unknown"}`,
+            });
+        });
+        return () => {
+            live = false;
+        };
+    }, [source, loadSurface, hooks]);
+    if (state.error !== undefined)
+        return renderError(state.error);
+    if (state.component === undefined)
+        return fallback ?? null;
+    const View = state.component;
+    return (_jsx(WrittenBoundary, { render: (message) => renderError(`This view stopped while drawing: ${message}`), children: _jsx(View, { rows: rows, columns: columns, labels: labels, links: links }) }, source));
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@manta-eu/horns-kit",
+  "version": "0.1.0",
+  "description": "Manta Horns component kit: charts and snapshot views that render on a server and hydrate in any React host, and the components the HornView sandbox runs.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/manta-eu/manta-horns.git",
+    "directory": "packages/horns-kit"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/embed/server.d.ts",
+      "default": "./dist/embed/server.js"
+    },
+    "./client": {
+      "types": "./dist/embed/client.d.ts",
+      "default": "./dist/embed/client.js"
+    },
+    "./catalog": {
+      "types": "./dist/catalog.d.ts",
+      "default": "./dist/catalog.js"
+    },
+    "./shape-views": {
+      "types": "./dist/shape-views/index.d.ts",
+      "default": "./dist/shape-views/index.js"
+    },
+    "./written": {
+      "types": "./dist/written/index.d.ts",
+      "default": "./dist/written/index.js"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "sucrase": "^3.35.1",
+    "ts-pattern": "^5.9.0",
+    "@manta-eu/horns": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.7",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json",
+    "types": "tsc --noEmit && tsc -p tsconfig.build.json --noEmit",
+    "test": "vitest run",
+    "catalog:snapshot": "node scripts/snapshot-react-catalog.ts"
+  }
+}