@gradial/aci 0.1.1 → 0.1.3

package/src/types/page.ts

@@ -0,0 +1,48 @@
+import type { RenderMode, VaryDimension } from './render-mode.js';
+
+export interface PageDocument {
+  path: string;
+  layout: string;
+  locale: string;
+  metadata: PageMetadata;
+  regions: Record<string, RegionNode>;
+  renderMode: RenderMode;
+}
+
+export interface PageMetadata {
+  title: string;
+  description?: string;
+  openGraph?: Record<string, string>;
+  canonicalUrl?: string;
+  alternateLocales?: { locale: string; path: string }[];
+  customHead?: string[];
+}
+
+export interface RegionNode {
+  kind: 'region';
+  name: string;
+  children: Array<BlockNode | FragmentRefNode>;
+}
+
+export interface BlockNode {
+  kind: 'block';
+  id: string;
+  component: string;
+  props: Record<string, unknown>;
+  renderHints: BlockRenderHints;
+  contentRef?: string;
+}
+
+export interface BlockRenderHints {
+  canStatic: boolean;
+  needsSSR: boolean;
+  isIsland: boolean;
+  islandMode?: 'ssr' | 'client';
+  varyDimensions?: VaryDimension[];
+}
+
+export interface FragmentRefNode {
+  kind: 'fragment-ref';
+  fragmentId: string;
+  inline: boolean;
+}

package/src/types/render-mode.ts

@@ -0,0 +1,18 @@
+export type RenderMode =
+  | 'static'
+  | 'static-with-fragments'
+  | 'prerender-on-demand'
+  | 'ssr-page'
+  | 'ssr-island'
+  | 'client-island';
+
+export type IslandMode = 'ssr' | 'client';
+
+export type VaryDimension =
+  | 'geo:country'
+  | 'geo:region'
+  | 'geo:city'
+  | `cookie:${string}`
+  | `header:${string}`
+  | 'locale'
+  | `query:${string}`;

package/src/types/renderer.ts

@@ -0,0 +1,83 @@
+import type { PageDocument } from './page.js';
+import type { VaryDimension } from './render-mode.js';
+
+export interface RenderCapabilities {
+  staticRender: boolean;
+  ssr: boolean;
+  ssrIslands: boolean;
+  clientIslands: boolean;
+  fragmentRender: boolean;
+}
+
+export interface GradialRenderer {
+  renderPage(request: RenderPageRequest): Promise<RenderPageResult>;
+  renderFragment?(request: RenderFragmentRequest): Promise<RenderResult>;
+  renderIsland?(request: RenderIslandRequest): Promise<RenderResult>;
+}
+
+export interface RenderPageRequest {
+  page: PageDocument;
+  requestContext?: RequestContext;
+  release: ReleaseContext;
+}
+
+export interface RequestContext {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  cookies: Record<string, string>;
+  geo?: GeoContext;
+}
+
+export interface GeoContext {
+  country?: string;
+  region?: string;
+  city?: string;
+}
+
+export interface ReleaseContext {
+  releaseId: string;
+  codeDigest: string;
+  contentSnapshotId: string;
+  assetUrl(logicalPath: string): string;
+}
+
+export interface RenderFragmentRequest {
+  fragmentId: string;
+  content: unknown;
+  release: ReleaseContext;
+}
+
+export interface RenderIslandRequest {
+  islandId: string;
+  component: string;
+  props: Record<string, unknown>;
+  requestContext: RequestContext;
+  release: ReleaseContext;
+}
+
+export interface RenderResult {
+  html: string;
+  status?: number;
+  headers?: Record<string, string>;
+  cachePolicy?: CachePolicy;
+}
+
+export interface RenderPageResult extends RenderResult {
+  islands?: IslandDescriptor[];
+}
+
+export interface IslandDescriptor {
+  islandId: string;
+  component: string;
+  props: Record<string, unknown>;
+  mode: 'ssr' | 'client';
+  varyDimensions?: VaryDimension[];
+}
+
+export interface CachePolicy {
+  scope: 'public' | 'private' | 'no-store';
+  ttl?: number;
+  staleWhileRevalidate?: number;
+  tags?: string[];
+}

package/src/types/video.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { GradialImageSchema, type GradialImage } from './image.js';
+
+// ---------------------------------------------------------------------------
+// Video source variant (format alternatives)
+// ---------------------------------------------------------------------------
+
+export interface VideoSource {
+  src: string;
+  type: string; // MIME type: video/mp4, video/webm
+}
+
+// ---------------------------------------------------------------------------
+// GradialVideo — DAM-backed video asset with compiler-resolved derivatives
+// ---------------------------------------------------------------------------
+
+export interface GradialVideo {
+  /** Discriminator — always 'gradial.video'. */
+  $type: 'gradial.video';
+  /** DAM asset identifier. */
+  assetId: string;
+  /** DAM version identifier. */
+  versionId: string;
+  /** Accessible description of the video content. */
+  alt: string;
+  /** Primary video URL (compiler-resolved). */
+  src: string;
+  /** Primary video MIME type (e.g. 'video/mp4'). */
+  type: string;
+  /** Intrinsic width in pixels. */
+  width: number;
+  /** Intrinsic height in pixels. */
+  height: number;
+  /**
+   * Poster frame — a full GradialImage with responsive srcset.
+   * The compiler extracts or generates this from the video asset.
+   */
+  poster?: GradialImage;
+  /** Format variants (e.g. mp4 + webm). Maps to <video><source> elements. */
+  sources?: VideoSource[];
+  /** Duration in seconds (if known). */
+  duration?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Zod schema
+// ---------------------------------------------------------------------------
+
+export const VideoSourceSchema = z.object({
+  src: z.string().min(1),
+  type: z.string().min(1),
+});
+
+export const GradialVideoSchema = z.object({
+  $type: z.literal('gradial.video'),
+  assetId: z.string().min(1),
+  versionId: z.string().min(1),
+  alt: z.string(),
+  src: z.string().min(1),
+  type: z.string().min(1),
+  width: z.number().int().nonnegative(),
+  height: z.number().int().nonnegative(),
+  poster: GradialImageSchema.optional(),
+  sources: z.array(VideoSourceSchema).optional(),
+  duration: z.number().nonnegative().optional(),
+});

package/src/cli/css-stub-loader.mjs

@@ -1,27 +0,0 @@
-/**
- * Node.js custom loader that stubs CSS module imports.
- * Used by CLI tools (compile-registry, validate-content) that need to import
- * component files without actually loading CSS.
- *
- * Usage: node --import tsx --loader ./css-stub-loader.mjs <script>
- */
-
-const CSS_EXTENSIONS = ['.css', '.module.css', '.scss', '.module.scss', '.less'];
-
-export function resolve(specifier, context, nextResolve) {
-  if (CSS_EXTENSIONS.some((ext) => specifier.endsWith(ext))) {
-    return { url: `css-stub:${specifier}`, shortCircuit: true };
-  }
-  return nextResolve(specifier, context);
-}
-
-export function load(url, context, nextLoad) {
-  if (url.startsWith('css-stub:')) {
-    return {
-      format: 'module',
-      source: 'export default {};',
-      shortCircuit: true,
-    };
-  }
-  return nextLoad(url, context);
-}

package/src/cli/generate-registry.mjs

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-/**
- * generate-registry — Derives a runtime registry from co-located component contracts.
- *
- * Usage:
- *   baremetal generate-registry --contracts <path> --output <path>
- *
- * --contracts  Path to the aggregation module (default-exports an array of ComponentContract).
- * --output     Path to the generated TypeScript file.
- *
- * The generated file imports the contracts module and derives:
- *   - `registry`: a flat map of component name -> component function (for the renderer)
- *   - `contractMap`: a flat map of component name -> full contract (for tooling/validation)
- */
-import { writeFile, mkdir } from 'node:fs/promises';
-import path from 'node:path';
-
-const args = parseArgs(process.argv.slice(2));
-
-if (!args.contracts) {
-  console.error('Error: --contracts <path> is required');
-  process.exitCode = 1;
-} else if (!args.output) {
-  console.error('Error: --output <path> is required');
-  process.exitCode = 1;
-} else {
-  try {
-    await generateRegistry(args);
-    console.log(`Registry generated at ${args.output}`);
-  } catch (error) {
-    console.error(`Error: ${error?.message ?? error}`);
-    process.exitCode = 1;
-  }
-}
-
-async function generateRegistry({ contracts, output }) {
-  const contractsPath = contracts.replace(/\.(ts|tsx|js|mjs)$/, '');
-  const outputPath = path.resolve(output);
-
-  await mkdir(path.dirname(outputPath), { recursive: true });
-
-  const content = `// AUTO-GENERATED — do not edit. Run \`baremetal generate-registry\` to regenerate.
-import type { ComponentContract } from '@baremetal/sdk';
-import contracts from '${contractsPath}';
-
-export const registry = Object.fromEntries(
-  contracts.filter((c) => c.component != null).map((c) => [c.name, c.component]),
-);
-
-export const contractMap: Record<string, ComponentContract> = Object.fromEntries(
-  contracts.map((c) => [c.name, c]),
-);
-`;
-
-  await writeFile(outputPath, content, 'utf-8');
-}
-
-function parseArgs(argv) {
-  const out = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg.startsWith('--')) continue;
-    const body = arg.slice(2);
-    const equals = body.indexOf('=');
-    if (equals >= 0) {
-      out[body.slice(0, equals)] = body.slice(equals + 1);
-      continue;
-    }
-    out[body] = argv[++i];
-  }
-  return out;
-}