@gradial/aci 0.1.0

package/dist/content/types.d.ts

@@ -0,0 +1,105 @@
+export type ButtonVariant = 'primary' | 'secondary' | 'tertiary' | 'outline' | 'ghost';
+export interface KernelImage {
+    src: string;
+    alt?: string;
+}
+export interface KernelLink {
+    id: string;
+    label: string;
+    href: string;
+    variant?: ButtonVariant;
+    icon?: string;
+}
+export interface NavItem extends KernelLink {
+}
+export interface UtilityItem extends KernelLink {
+}
+export interface FooterLink extends KernelLink {
+}
+export interface FooterGroup {
+    id: string;
+    title: string;
+    links: FooterLink[];
+}
+export interface FooterColumn {
+    id: string;
+    title?: string;
+    groups?: FooterGroup[];
+    links?: FooterLink[];
+}
+export interface SiteFooter {
+    columns?: FooterColumn[];
+    social?: FooterLink[];
+    legalLinks?: FooterLink[];
+    copyright?: string;
+}
+export type KernelFooterGroup = FooterGroup;
+export type KernelFooterColumn = FooterColumn;
+export interface KernelPageSeo {
+    title?: string;
+    description?: string;
+    canonical?: string;
+}
+export interface KernelPageBlock {
+    id: string;
+    component: string;
+    props: Record<string, unknown>;
+}
+export interface KernelAtomicBlock {
+    id: string;
+    component: string;
+    props: Record<string, unknown>;
+}
+export interface KernelPage {
+    id: string;
+    $type: 'page';
+    status: string;
+    layout: string;
+    renderMode: string;
+    metadata: KernelPageSeo;
+    regions: Record<string, KernelPageBlock[]>;
+}
+export interface KernelSiteConfig {
+    id: string;
+    $type: 'site';
+    status: string;
+    title: string;
+    domain: string;
+    defaultLocale: string;
+    locales?: string[];
+    overlayResolution?: string[];
+    brandHref?: string;
+    brandLogo?: KernelImage;
+    navigation?: NavItem[];
+    utilities?: UtilityItem[];
+    promo?: Record<string, unknown>;
+    footer?: SiteFooter;
+    seo?: {
+        title?: string;
+        description?: string;
+        siteName?: string;
+    };
+}
+export interface KernelRouteMetadata {
+    title: string;
+    description: string;
+    canonical?: string;
+    siteName: string;
+}
+export interface RenderInput<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> {
+    route: string;
+    domain: string;
+    locale: string;
+    siteConfig: TSiteConfig;
+    page: TPage | null;
+}
+export interface RenderOutput {
+    route: string;
+    html: string;
+    assets: {
+        css: string[];
+        js: string[];
+        images: string[];
+    };
+    diagnostics: string[];
+}

package/dist/content/types.js

@@ -0,0 +1 @@
+export {};

package/dist/content/validation.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { type AtomicBlockContract, type BlockContract, type ContractField } from './contract.js';
+import type { KernelPage, KernelSiteConfig } from './types.js';
+export interface ContentValidationContracts {
+    blockContracts?: readonly BlockContract[];
+    atomicBlockContracts?: readonly AtomicBlockContract[];
+}
+export interface ContentSchemas {
+    siteConfigSchema: z.ZodTypeAny;
+    atomicBlockSchema: z.ZodTypeAny;
+    pageBlockSchema: z.ZodTypeAny;
+    pageSchema: z.ZodTypeAny;
+    schemaFromContractField(field: ContractField): z.ZodTypeAny;
+    schemaFromContractFields(fields: Record<string, ContractField>): z.ZodTypeAny;
+    parseKernelSiteConfig(value: unknown, source?: string): KernelSiteConfig;
+    parseKernelPage(value: unknown, source?: string): KernelPage;
+}
+export declare const linkSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    href: z.ZodString;
+}, z.core.$loose>;
+export declare const imageSchema: z.ZodObject<{
+    src: z.ZodString;
+    alt: z.ZodString;
+}, z.core.$loose>;
+export declare const optionalImageSchema: z.ZodObject<{
+    src: z.ZodString;
+    alt: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const siteConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    $type: z.ZodLiteral<"site">;
+    status: z.ZodString;
+    title: z.ZodString;
+    domain: z.ZodString;
+    defaultLocale: z.ZodString;
+    brandHref: z.ZodOptional<z.ZodString>;
+    brandLogo: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    navigation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$loose>>>;
+    utilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        variant: z.ZodOptional<z.ZodEnum<{
+            primary: "primary";
+            secondary: "secondary";
+            tertiary: "tertiary";
+            outline: "outline";
+            ghost: "ghost";
+        }>>;
+        id: z.ZodString;
+        label: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$loose>>>;
+    promo: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    footer: z.ZodOptional<z.ZodObject<{
+        columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                links: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    href: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>>;
+            links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                href: z.ZodString;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>>;
+        social: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            icon: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            label: z.ZodString;
+            href: z.ZodString;
+        }, z.core.$loose>>>;
+        legalLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            href: z.ZodString;
+        }, z.core.$loose>>>;
+        copyright: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    seo: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        siteName: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare function createContentSchemas(contracts?: ContentValidationContracts): ContentSchemas;
+export declare function formatZodError(source: string, error: z.ZodError): string;
+export declare function parseWithSchema(schema: z.ZodTypeAny, value: unknown, source: string): unknown;
+export declare const atomicBlockSchema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+export declare const pageBlockSchema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+export declare const pageSchema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+export declare const schemaFromContractField: (field: ContractField) => z.ZodTypeAny;
+export declare const schemaFromContractFields: (fields: Record<string, ContractField>) => z.ZodTypeAny;
+export declare const parseKernelSiteConfig: (value: unknown, source?: string) => KernelSiteConfig;
+export declare const parseKernelPage: (value: unknown, source?: string) => KernelPage;

package/dist/content/validation.js

@@ -0,0 +1,184 @@
+import { z } from 'zod';
+import { defaultAtomicBlockContracts, defaultBlockContracts, } from './contract.js';
+import { validateContentClassName, validateComponentClassName } from './tailwind-validator.js';
+const linkFields = {
+    id: z.string().min(1),
+    label: z.string().min(1),
+    href: z.string().min(1),
+};
+export const linkSchema = z.looseObject(linkFields);
+export const imageSchema = z.looseObject({
+    src: z.string().min(1),
+    alt: z.string().min(1),
+});
+export const optionalImageSchema = z.looseObject({
+    src: z.string().min(1),
+    alt: z.string().optional(),
+});
+export const siteConfigSchema = z.looseObject({
+    id: z.string().min(1),
+    $type: z.literal('site'),
+    status: z.string().min(1),
+    title: z.string().min(1),
+    domain: z.string().min(1),
+    defaultLocale: z.string().min(1),
+    brandHref: z.string().optional(),
+    brandLogo: optionalImageSchema.optional(),
+    navigation: z.array(linkSchema).optional(),
+    utilities: z.array(z.looseObject({
+        ...linkFields,
+        variant: z.enum(['primary', 'secondary', 'tertiary', 'outline', 'ghost']).optional(),
+    })).optional(),
+    promo: z.record(z.string(), z.unknown()).optional(),
+    footer: z.looseObject({
+        columns: z.array(z.looseObject({
+            id: z.string().min(1),
+            title: z.string().optional(),
+            groups: z.array(z.looseObject({
+                id: z.string().min(1),
+                title: z.string(),
+                links: z.array(linkSchema),
+            })).optional(),
+            links: z.array(linkSchema).optional(),
+        })).optional(),
+        social: z.array(z.looseObject({
+            ...linkFields,
+            icon: z.string().optional(),
+        })).optional(),
+        legalLinks: z.array(linkSchema).optional(),
+        copyright: z.string().optional(),
+    }).optional(),
+    seo: z.looseObject({
+        title: z.string().optional(),
+        description: z.string().optional(),
+        siteName: z.string().optional(),
+    }).optional(),
+});
+function withOptional(schema, field) {
+    return field.optional ? schema.optional() : schema;
+}
+export function createContentSchemas(contracts = {}) {
+    const blockContracts = contracts.blockContracts ?? defaultBlockContracts;
+    const atomicBlockContracts = contracts.atomicBlockContracts ?? defaultAtomicBlockContracts;
+    let atomicBlockSchema;
+    function schemaFromContractField(field) {
+        switch (field.kind) {
+            case 'atomicBlocks':
+                return withOptional(z.array(atomicBlockSchema), field);
+            case 'array':
+                return withOptional(z.array(schemaFromContractField(field.items)), field);
+            case 'boolean':
+                return withOptional(z.boolean(), field);
+            case 'className': {
+                const schema = z.string().check((ctx) => {
+                    const result = validateContentClassName(ctx.value);
+                    if (!result.valid) {
+                        ctx.issues.push({
+                            code: 'custom',
+                            message: `Invalid Tailwind classes: ${result.invalidClasses.join(', ')}. Use standard utilities only; arbitrary bracket values are not allowed in content.`,
+                            input: ctx.value,
+                        });
+                    }
+                });
+                return withOptional(schema, field);
+            }
+            case 'componentClassName': {
+                const schema = z.string().check((ctx) => {
+                    const result = validateComponentClassName(ctx.value);
+                    if (!result.valid) {
+                        ctx.issues.push({
+                            code: 'custom',
+                            message: `Invalid Tailwind classes: ${result.invalidClasses.join(', ')}. Raw dimension/color bracket values (for example [12px] or [#fff]) are not allowed.`,
+                            input: ctx.value,
+                        });
+                    }
+                });
+                return withOptional(schema, field);
+            }
+            case 'enum':
+                return withOptional(z.enum(field.values), field);
+            case 'image':
+                return withOptional(imageSchema, field);
+            case 'object':
+                return withOptional(schemaFromContractFields(field.fields), field);
+            case 'richText':
+                return withOptional(z.string(), field);
+            case 'string': {
+                const schema = typeof field.minLength === 'number'
+                    ? z.string().min(field.minLength)
+                    : z.string();
+                return withOptional(schema, field);
+            }
+        }
+    }
+    function schemaFromContractFields(fields) {
+        return z.looseObject(Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, schemaFromContractField(field)])));
+    }
+    atomicBlockSchema = discriminatedContractUnion('atomic block', atomicBlockContracts, schemaFromContractFields);
+    const pageBlockSchema = discriminatedContractUnion('page block', blockContracts, schemaFromContractFields);
+    const pageSchema = z.looseObject({
+        id: z.string().min(1),
+        $type: z.literal('page'),
+        status: z.string().min(1),
+        layout: z.string().min(1),
+        renderMode: z.string().min(1),
+        metadata: z.looseObject({
+            title: z.string().optional(),
+            description: z.string().optional(),
+            canonical: z.string().optional(),
+        }),
+        regions: z.record(z.string(), z.array(pageBlockSchema)),
+    });
+    return {
+        siteConfigSchema,
+        atomicBlockSchema,
+        pageBlockSchema,
+        pageSchema,
+        schemaFromContractField,
+        schemaFromContractFields,
+        parseKernelSiteConfig(value, source = 'site.json') {
+            return parseWithSchema(siteConfigSchema, value, source);
+        },
+        parseKernelPage(value, source = '_index.json') {
+            return parseWithSchema(pageSchema, value, source);
+        },
+    };
+}
+function discriminatedContractUnion(label, contracts, schemaFromContractFields) {
+    if (contracts.length === 0) {
+        throw new Error(`At least one ${label} contract is required`);
+    }
+    const schemas = contracts.map((block) => z.looseObject({
+        id: z.string().min(1),
+        component: z.literal(block.component),
+        props: schemaFromContractFields(block.props),
+    }));
+    if (schemas.length === 1) {
+        return schemas[0];
+    }
+    return z.discriminatedUnion('component', schemas);
+}
+export function formatZodError(source, error) {
+    const issues = error.issues
+        .map((issue) => {
+        const path = issue.path.length ? issue.path.join('.') : '<root>';
+        return `- ${path}: ${issue.message}`;
+    })
+        .join('\n');
+    return `Invalid bare-metal content in ${source}:\n${issues}`;
+}
+export function parseWithSchema(schema, value, source) {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        throw new Error(formatZodError(source, parsed.error));
+    }
+    return parsed.data;
+}
+const defaultContentSchemas = createContentSchemas();
+export const atomicBlockSchema = defaultContentSchemas.atomicBlockSchema;
+export const pageBlockSchema = defaultContentSchemas.pageBlockSchema;
+export const pageSchema = defaultContentSchemas.pageSchema;
+export const schemaFromContractField = defaultContentSchemas.schemaFromContractField;
+export const schemaFromContractFields = defaultContentSchemas.schemaFromContractFields;
+export const parseKernelSiteConfig = defaultContentSchemas.parseKernelSiteConfig;
+export const parseKernelPage = defaultContentSchemas.parseKernelPage;

package/dist/define-component.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentContract, ComponentDefinition } from './types/component.js';
+export declare function defineComponent<TSchema = unknown>(definition: ComponentDefinition<TSchema>): ComponentContract<TSchema>;

package/dist/define-component.js

@@ -0,0 +1,13 @@
+export function defineComponent(definition) {
+    const renderModes = definition.renderModes ?? definition.render;
+    if (!renderModes) {
+        throw new Error(`component ${definition.name} must define renderModes`);
+    }
+    return {
+        ...definition,
+        renderModes,
+        render: renderModes,
+        varyDimensions: definition.varyDimensions ?? definition.vary,
+        vary: definition.vary ?? definition.varyDimensions,
+    };
+}

package/dist/define-layout.d.ts

@@ -0,0 +1,3 @@
+import type { LayoutContract, LayoutDefinition, LayoutSlot } from './types/layout.js';
+export declare function defineLayout(definition: LayoutDefinition): LayoutContract;
+export declare function slot(name: string, required?: boolean): LayoutSlot;

package/dist/define-layout.js

@@ -0,0 +1,6 @@
+export function defineLayout(definition) {
+    return definition;
+}
+export function slot(name, required = false) {
+    return { name, required };
+}

package/dist/dev/browser.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_DEV_REFRESH_PORT = 24680;
+export declare const DEFAULT_DEV_REFRESH_PATH = "/baremetal-dev";
+export interface DevRefreshOptions {
+    wsPort?: number | string;
+    path?: string;
+    reconnectMs?: number;
+}

package/dist/dev/browser.js

@@ -0,0 +1,2 @@
+export const DEFAULT_DEV_REFRESH_PORT = 24680;
+export const DEFAULT_DEV_REFRESH_PATH = '/baremetal-dev';

package/dist/dev/index.d.ts

@@ -0,0 +1,30 @@
+import { type DevRefreshOptions } from './browser.js';
+export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, type DevRefreshOptions } from './browser.js';
+declare global {
+    interface Window {
+        __bareMetalDevRefresh?: boolean;
+    }
+}
+export interface BareMetalContentWatchOptions extends DevRefreshOptions {
+    contentRoot?: string;
+    enabled?: boolean;
+}
+interface ViteDevServerLike {
+    watcher: {
+        add(path: string): void;
+        on(event: string, callback: (eventName: string, filePath: string) => void): void;
+    };
+    ws: {
+        send(payload: unknown): void;
+    };
+}
+export interface VitePluginLike {
+    name: string;
+    apply?: 'serve' | 'build';
+    configureServer?(server: ViteDevServerLike): void;
+    transformIndexHtml?(html: string): string;
+}
+export declare function devRefreshPort(options?: DevRefreshOptions): number;
+export declare function devRefreshScript(options?: DevRefreshOptions): string;
+export declare function devRefreshScriptTag(options?: DevRefreshOptions): string;
+export declare function baremetalContentWatchPlugin(options?: BareMetalContentWatchOptions): VitePluginLike;

package/dist/dev/index.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+import { contentRoot } from '../content/routes.js';
+import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from './browser.js';
+export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT } from './browser.js';
+function numberOption(value, fallback) {
+    if (value === undefined || value === '') {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function devRefreshPort(options = {}) {
+    const value = options.wsPort ?? process.env.BARE_METAL_DEV_WS_PORT;
+    if (value === 0 || value === '0') {
+        return 0;
+    }
+    return numberOption(value, DEFAULT_DEV_REFRESH_PORT);
+}
+export function devRefreshScript(options = {}) {
+    const wsPort = devRefreshPort(options);
+    if (wsPort <= 0) {
+        return '';
+    }
+    const wsPath = options.path || DEFAULT_DEV_REFRESH_PATH;
+    const reconnectMs = numberOption(options.reconnectMs, 1000);
+    return `(() => {
+  if (typeof window === 'undefined' || window.__bareMetalDevRefresh) return;
+  window.__bareMetalDevRefresh = true;
+  const port = ${JSON.stringify(wsPort)};
+  const path = ${JSON.stringify(wsPath)};
+  const reconnectMs = ${JSON.stringify(reconnectMs)};
+  const connect = () => {
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const socket = new WebSocket(protocol + '//' + window.location.hostname + ':' + port + path);
+    socket.addEventListener('message', (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        if (message && message.type === 'content-updated') window.location.reload();
+      } catch (_) {
+      }
+    });
+    socket.addEventListener('close', () => window.setTimeout(connect, reconnectMs));
+  };
+  connect();
+})();`;
+}
+export function devRefreshScriptTag(options = {}) {
+    return `<script>${devRefreshScript(options)}</script>`;
+}
+export function baremetalContentWatchPlugin(options = {}) {
+    const enabled = options.enabled ?? process.env.BARE_METAL_DISABLE_CONTENT_WATCH !== '1';
+    return {
+        name: 'baremetal-content-watch',
+        apply: 'serve',
+        configureServer(server) {
+            if (!enabled) {
+                return;
+            }
+            const root = path.resolve(options.contentRoot || contentRoot());
+            server.watcher.add(root);
+            server.watcher.on('all', (_eventName, filePath) => {
+                const changed = path.resolve(filePath);
+                const relative = path.relative(root, changed);
+                if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+                    server.ws.send({ type: 'full-reload', path: '*' });
+                }
+            });
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './define-component.js';
+export * from './define-layout.js';
+export * from './types/index.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './define-component.js';
+export * from './define-layout.js';
+export * from './types/index.js';

package/dist/next/dev-refresh.d.ts

@@ -0,0 +1,5 @@
+import { type DevRefreshOptions } from '../dev/browser.js';
+export interface DevRefreshProps extends DevRefreshOptions {
+    enabled?: boolean;
+}
+export declare function DevRefresh({ enabled, wsPort, path, reconnectMs, }: DevRefreshProps): null;

package/dist/next/dev-refresh.js

@@ -0,0 +1,44 @@
+'use client';
+import { useEffect } from 'react';
+import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from '../dev/browser.js';
+export function DevRefresh({ enabled = process.env.NODE_ENV !== 'production', wsPort = DEFAULT_DEV_REFRESH_PORT, path = DEFAULT_DEV_REFRESH_PATH, reconnectMs = 1000, }) {
+    useEffect(() => {
+        if (!enabled || Number(wsPort) <= 0 || typeof window === 'undefined' || window.__bareMetalDevRefresh) {
+            return undefined;
+        }
+        window.__bareMetalDevRefresh = true;
+        let reconnectTimer;
+        let socket;
+        let active = true;
+        const connect = () => {
+            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+            socket = new WebSocket(`${protocol}//${window.location.hostname}:${Number(wsPort)}${path}`);
+            socket.addEventListener('message', (event) => {
+                try {
+                    const message = JSON.parse(event.data);
+                    if (message?.type === 'content-updated') {
+                        window.location.reload();
+                    }
+                }
+                catch {
+                    // Ignore non-Bare Metal dev server frames.
+                }
+            });
+            socket.addEventListener('close', () => {
+                if (active) {
+                    reconnectTimer = setTimeout(connect, Number(reconnectMs));
+                }
+            });
+        };
+        connect();
+        return () => {
+            active = false;
+            window.__bareMetalDevRefresh = false;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+            }
+            socket?.close();
+        };
+    }, [enabled, wsPort, path, reconnectMs]);
+    return null;
+}

package/dist/next/middleware.d.ts

@@ -0,0 +1,8 @@
+import { type NextRequest } from 'next/server';
+export interface GradialMiddlewareConfig {
+    siteId: string;
+    edgeConfig?: string;
+    previewSignKey?: string;
+    deploymentId?: string;
+}
+export declare function createGradialMiddleware(config: GradialMiddlewareConfig): (request: NextRequest) => Promise<Response>;