blockprint 0.0.1 → 0.1.0

package/README.md

@@ -20,6 +20,8 @@ Renders a config against a registry. `config` is `unknown` on purpose — the ou
 
 The default fallback renders a warning box in development and `null` in production.
 
+The optional `wrapBlock={(node, entry, index) => …}` prop wraps every rendered entry — blocks and fallbacks alike — with access to the config entry and its index. This is the hook point for visual-editing overlays, analytics boundaries, or per-block chrome.
+
 ### `parseConfig(input)`
 
 The boundary validator, exported for consumers who want to fail at fetch time rather than render time. Throws `ConfigError` with the entry index and reason.

package/dist/Renderer.d.ts

@@ -1,9 +1,15 @@
 import type { ComponentType, ReactNode } from "react";
-import type { BlocksShape, FallbackProps, Registry } from "./types";
+import type { BlockConfig, BlocksShape, FallbackProps, Registry } from "./types";
 export interface RendererProps<T extends BlocksShape> {
     /** Untrusted input; the outer shape is validated internally. */
     config: unknown;
     registry: Registry<T>;
     fallback?: ComponentType<FallbackProps>;
+    /**
+     * Wraps every rendered entry — blocks and fallbacks alike — with access to
+     * the config entry and its index. The hook point for visual-editing
+     * overlays, analytics boundaries, or per-block chrome.
+     */
+    wrapBlock?: (node: ReactNode, entry: BlockConfig, index: number) => ReactNode;
 }
-export declare function Renderer<T extends BlocksShape>({ config, registry, fallback, }: RendererProps<T>): ReactNode;
+export declare function Renderer<T extends BlocksShape>({ config, registry, fallback, wrapBlock, }: RendererProps<T>): ReactNode;

package/dist/Renderer.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment } from "react";
 import { parseConfig } from "./parseConfig";
 import { DefaultFallback } from "./fallback";
 // `memo`/`forwardRef` components are exotic objects, not functions, so the
@@ -9,32 +10,37 @@ function resolveDef(def) {
     }
     return { component: def };
 }
-export function Renderer({ config, registry, fallback, }) {
+export function Renderer({ config, registry, fallback, wrapBlock, }) {
     const Fallback = fallback ?? DefaultFallback;
     const entries = parseConfig(config);
     return entries.map((entry, index) => {
         const key = entry.id ?? `${entry.type}-${index}`;
-        if (!Object.hasOwn(registry.blocks, entry.type)) {
-            return (_jsx(Fallback, { reason: "unknown-type", type: entry.type, props: entry.props }, key));
+        const node = renderEntry(entry, registry, Fallback);
+        // The key lives on a Fragment so it survives whatever wrapBlock returns.
+        return (_jsx(Fragment, { children: wrapBlock ? wrapBlock(node, entry, index) : node }, key));
+    });
+}
+function renderEntry(entry, registry, Fallback) {
+    if (!Object.hasOwn(registry.blocks, entry.type)) {
+        return (_jsx(Fallback, { reason: "unknown-type", type: entry.type, props: entry.props }));
+    }
+    const { component: Component, schema } = resolveDef(registry.blocks[entry.type]);
+    let props = entry.props;
+    if (schema) {
+        const result = schema["~standard"].validate(entry.props);
+        // React render is synchronous; async schemas are a config mistake and
+        // are contained like any other invalid block.
+        if (result instanceof Promise) {
+            return (_jsx(Fallback, { reason: "invalid-props", type: entry.type, props: entry.props, issues: [
+                    {
+                        message: "schema validated asynchronously; blockprint only supports synchronous schemas",
+                    },
+                ] }));
         }
-        const { component: Component, schema } = resolveDef(registry.blocks[entry.type]);
-        let props = entry.props;
-        if (schema) {
-            const result = schema["~standard"].validate(entry.props);
-            // React render is synchronous; async schemas are a config mistake and
-            // are contained like any other invalid block.
-            if (result instanceof Promise) {
-                return (_jsx(Fallback, { reason: "invalid-props", type: entry.type, props: entry.props, issues: [
-                        {
-                            message: "schema validated asynchronously; blockprint only supports synchronous schemas",
-                        },
-                    ] }, key));
-            }
-            if (result.issues) {
-                return (_jsx(Fallback, { reason: "invalid-props", type: entry.type, props: entry.props, issues: result.issues }, key));
-            }
-            props = result.value;
+        if (result.issues) {
+            return (_jsx(Fallback, { reason: "invalid-props", type: entry.type, props: entry.props, issues: result.issues }));
         }
-        return _jsx(Component, { ...props }, key);
-    });
+        props = result.value;
+    }
+    return _jsx(Component, { ...props });
 }

package/dist/types.d.ts

@@ -28,6 +28,15 @@ export interface BlockConfig {
     props?: unknown;
     id?: string | number;
 }
+/**
+ * The props a consumer may author for a definition. With a schema this is the
+ * schema's INPUT type — authored configs are pre-validation data, so fields
+ * with defaults are optional. (The component still receives the parsed
+ * output; see PropsOfDef.)
+ */
+export type InputOfDef<D> = D extends {
+    schema: StandardSchemaV1<infer I, any>;
+} ? I : PropsOfDef<D>;
 /**
  * The closed, fully typed config union for a given registry — for configs
  * authored in TypeScript rather than fetched from a CMS. Block names
@@ -36,7 +45,7 @@ export interface BlockConfig {
 export type ConfigFor<R extends Registry<BlocksShape>> = R extends Registry<infer T> ? Array<{
     [K in keyof T]: {
         type: K;
-        props: PropsOfDef<T[K]>;
+        props: InputOfDef<T[K]>;
         id?: string | number;
     };
 }[keyof T]> : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockprint",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Typed, config-driven block renderer for React. Render arbitrary UI trees from untrusted JSON with compile-time registry safety and runtime schema validation.",
   "license": "MIT",
   "repository": {