machinalayout 0.1.0 → 0.3.0

package/dist/handoff/index.d.ts

@@ -0,0 +1,44 @@
+import { M as MachinaDomSummary } from '../types-DLYAhNXw.js';
+import { M as MachinaViewport, a as MachinaScreenViewportTask } from '../screenCatalog-ZjonGiOi.js';
+import '../types-B90jb3RW.js';
+
+type MachinaHandoffArtifactPaths = {
+    screenshot?: string;
+    domSummary?: string;
+    layoutSnapshot?: string;
+    manifest: string;
+};
+type MachinaHandoffBundleManifest = {
+    schemaVersion: 1;
+    createdAt: string;
+    route?: string;
+    fixture?: string;
+    screenKey?: string;
+    viewportKey?: string;
+    viewport?: MachinaViewport;
+    tags?: readonly string[];
+    artifactBaseName?: string;
+    artifacts: MachinaHandoffArtifactPaths;
+    metadata?: Record<string, unknown>;
+};
+type WriteMachinaHandoffBundleInput = {
+    outputDir: string;
+    artifactBaseName?: string;
+    screenshotPath?: string;
+    domSummary?: MachinaDomSummary;
+    layoutSnapshot?: unknown;
+    task?: MachinaScreenViewportTask;
+    route?: string;
+    fixture?: string;
+    tags?: readonly string[];
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+};
+type WriteMachinaHandoffBundleResult = {
+    manifest: MachinaHandoffBundleManifest;
+    paths: MachinaHandoffArtifactPaths;
+};
+
+declare function writeMachinaHandoffBundle(input: WriteMachinaHandoffBundleInput): Promise<WriteMachinaHandoffBundleResult>;
+
+export { type MachinaHandoffArtifactPaths, type MachinaHandoffBundleManifest, type WriteMachinaHandoffBundleInput, type WriteMachinaHandoffBundleResult, writeMachinaHandoffBundle };

package/dist/handoff/index.js

@@ -0,0 +1,83 @@
+import {
+  slugMachinaArtifactName
+} from "../chunk-33CKBEJH.js";
+import "../chunk-VREK57S3.js";
+
+// src/handoff/writeMachinaHandoffBundle.ts
+import { copyFile, mkdir, writeFile } from "fs/promises";
+import path from "path";
+function artifactBaseName(input) {
+  const candidate = input.artifactBaseName ?? input.task?.artifactBaseName ?? [
+    input.route ?? input.task?.route,
+    input.fixture ?? input.task?.fixture,
+    input.task?.viewportKey
+  ].filter((part) => typeof part === "string" && part.trim() !== "").join("-") ?? "";
+  return slugMachinaArtifactName(candidate === "" ? "machina-handoff" : candidate);
+}
+function orderedUnique(...groups) {
+  const result = [];
+  for (const group of groups) {
+    for (const tag of group ?? []) {
+      if (!result.includes(tag)) result.push(tag);
+    }
+  }
+  return result.length === 0 ? void 0 : result;
+}
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function screenshotExtension(screenshotPath) {
+  const extension = path.extname(screenshotPath);
+  return extension === "" ? ".png" : extension;
+}
+async function writeMachinaHandoffBundle(input) {
+  if (typeof input.outputDir !== "string" || input.outputDir.trim() === "") {
+    throw new Error("outputDir must be a non-empty string");
+  }
+  const outputDir = path.resolve(input.outputDir);
+  await mkdir(outputDir, { recursive: true });
+  const base = artifactBaseName(input);
+  const artifactNames = { manifest: `${base}__handoff.json` };
+  const paths = {
+    manifest: path.join(outputDir, artifactNames.manifest)
+  };
+  if (input.screenshotPath !== void 0) {
+    artifactNames.screenshot = `${base}__screenshot${screenshotExtension(input.screenshotPath)}`;
+    paths.screenshot = path.join(outputDir, artifactNames.screenshot);
+    await copyFile(input.screenshotPath, paths.screenshot);
+  }
+  if (input.domSummary !== void 0) {
+    artifactNames.domSummary = `${base}__dom-summary.json`;
+    paths.domSummary = path.join(outputDir, artifactNames.domSummary);
+    await writeFile(paths.domSummary, json(input.domSummary), "utf8");
+  }
+  if (input.layoutSnapshot !== void 0) {
+    artifactNames.layoutSnapshot = `${base}__machina-snapshot.json`;
+    paths.layoutSnapshot = path.join(outputDir, artifactNames.layoutSnapshot);
+    await writeFile(paths.layoutSnapshot, json(input.layoutSnapshot), "utf8");
+  }
+  const tags = orderedUnique(input.task?.tags, input.tags);
+  const manifest = {
+    schemaVersion: 1,
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    artifacts: artifactNames
+  };
+  const route = input.route ?? input.task?.route;
+  const fixture = input.fixture ?? input.task?.fixture;
+  if (route !== void 0) manifest.route = route;
+  if (fixture !== void 0) manifest.fixture = fixture;
+  if (input.task !== void 0) {
+    manifest.screenKey = input.task.screenKey;
+    manifest.viewportKey = input.task.viewportKey;
+    manifest.viewport = input.task.viewport;
+  }
+  if (tags !== void 0) manifest.tags = tags;
+  manifest.artifactBaseName = base;
+  if (input.metadata !== void 0) manifest.metadata = input.metadata;
+  await writeFile(paths.manifest, json(manifest), "utf8");
+  return { manifest, paths };
+}
+export {
+  writeMachinaHandoffBundle
+};

package/dist/index.d.ts

@@ -1,128 +1,14 @@
-import React from 'react';
-
-type NodeId = string;
-type Rect = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-type AbsoluteFrame = {
-    kind: "absolute";
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-type UiLength = number | {
-    unit: "px";
-    value: number;
-} | {
-    unit: "ui";
-    value: number;
-};
-type OffsetSpec = {
-    x?: UiLength;
-    y?: UiLength;
-};
-type AnchorFrame = {
-    kind: "anchor";
-    left?: UiLength;
-    right?: UiLength;
-    top?: UiLength;
-    bottom?: UiLength;
-    width?: UiLength;
-    height?: UiLength;
-};
-type RootFrame = {
-    kind: "root";
-};
-type FixedFrame = {
-    kind: "fixed";
-    width: number;
-    height: number;
-};
-type FillFrame = {
-    kind: "fill";
-    weight?: number;
-    cross?: number | "fill";
-};
-type FrameSpec = RootFrame | AbsoluteFrame | AnchorFrame | FixedFrame | FillFrame;
-type StackAxis = "horizontal" | "vertical";
-type StackJustify = "start" | "center" | "end" | "space-between";
-type StackAlign = "start" | "center" | "end";
-type EdgeInsets = {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
-};
-type StackArrange = {
-    kind: "stack";
-    axis: StackAxis;
-    gap?: number;
-    padding?: number | EdgeInsets;
-    justify?: StackJustify;
-    align?: StackAlign;
-};
-type ArrangeSpec = StackArrange;
-type LayoutRow = {
-    id: NodeId;
-    parent?: NodeId;
-    order?: number;
-    z?: number;
-    frame: FrameSpec;
-    arrange?: ArrangeSpec;
-    view?: string;
-    slot?: string;
-    debugLabel?: string;
-    offset?: OffsetSpec;
-};
-type LayoutNode = {
-    id: NodeId;
-    z?: number;
-    frame: FrameSpec;
-    arrange?: ArrangeSpec;
-    view?: string;
-    slot?: string;
-    debugLabel?: string;
-    offset?: OffsetSpec;
-};
-type LayoutDocument = {
-    rootId: NodeId;
-    nodes: Record<NodeId, LayoutNode>;
-    children: Record<NodeId, NodeId[]>;
-};
-type ResolvedLayoutNode = {
-    id: NodeId;
-    z?: number;
-    rect: Rect;
-    frame: FrameSpec;
-    arrange?: ArrangeSpec;
-    view?: string;
-    slot?: string;
-    debugLabel?: string;
-    offset?: OffsetSpec;
-};
-type ResolvedLayoutDocument = {
-    rootId: NodeId;
-    nodes: Record<NodeId, ResolvedLayoutNode>;
-    children: Record<NodeId, NodeId[]>;
-};
-type ResolvedLayoutTree = {
-    id: NodeId;
-    z?: number;
-    rect: Rect;
-    frame: FrameSpec;
-    arrange?: ArrangeSpec;
-    view?: string;
-    slot?: string;
-    debugLabel?: string;
-    offset?: OffsetSpec;
-    children: ResolvedLayoutTree[];
-};
-
-type MachinaLayoutErrorCode = "EmptyRows" | "MissingRoot" | "MultipleRoots" | "DuplicateId" | "InvalidId" | "MissingParent" | "UnknownParent" | "SelfParent" | "Cycle" | "UnreachableNode" | "NonFiniteNumber" | "InvalidLengthUnit" | "InvalidZ" | "NegativeSize" | "NegativeGap" | "NegativePadding" | "InvalidAnchorHorizontal" | "InvalidAnchorVertical" | "NegativeResolvedSize" | "FixedFrameWithoutArranger" | "FillFrameWithoutArranger" | "InvalidFillWeight" | "StackChildMustBeFixed" | "StackContentNegative" | "StackOverflow" | "RootFrameNotRoot" | "RootFrameWithoutRoot";
+import { E as EdgeInsets, U as UiLength, R as Rect, O as OffsetSpec, L as LayoutRow, c as LayoutDocument, F as FrameSpec, b as ResolvedLayoutDocument, d as ResolvedLayoutTree, a as ResolvedLayoutNode, N as NodeId, e as LayerName, S as StackAxis, A as ArrangeSpec } from './types-B90jb3RW.js';
+export { f as AbsoluteFrame, g as AnchorFrame, C as CellFrame, h as EdgeRef, i as FillFrame, j as FixedFrame, G as GridArrange, k as GridTrack, l as GuideFrame, m as GuideLength, n as LayoutNode, o as LayoutRowVariant, p as LayoutVariantCondition, q as RectEdge, r as RootFrame, s as StackAlign, t as StackArrange, u as StackJustify } from './types-B90jb3RW.js';
+export { MachinaReactDebugOverlayOptions, MachinaReactView, MachinaReactViewProps, MachinaSlotProps } from './react/index.js';
+export { c as MachinaBulletItem, d as MachinaInline, e as MachinaTextAlign, f as MachinaTextBlock, g as MachinaTextDiagnostic, h as MachinaTextDiagnosticCode, i as MachinaTextDiagnosticLevel, b as MachinaTextDocument, j as MachinaTextLeading, k as MachinaTextOverflow, a as MachinaTextSource, M as MachinaTextSpec, l as MachinaTextVariant, m as MachinaTextVerticalAlign, n as MachinaTextWrap, P as ParseMachinaTextResult } from './types-C4poVJpR.js';
+export { parseMachinaText, parseMachinaTextInline } from './text/index.js';
+export { MachinaTextView, MachinaTextViewProps } from './text/react/index.js';
+export { b as MachinaScreen, c as MachinaScreenCatalog, a as MachinaScreenViewportTask, M as MachinaViewport, d as MachinaViewportMatrix, e as createViewportMatrix, f as defineMachinaScreens, g as defineMachinaViewports, h as expandScreenViewportTasks, i as getMachinaViewport, s as slugMachinaArtifactName } from './screenCatalog-ZjonGiOi.js';
+import 'react';
+import './debugOverlay-pJpj0n5H.js';
+
+type MachinaLayoutErrorCode = "EmptyRows" | "MissingRoot" | "MultipleRoots" | "DuplicateId" | "InvalidId" | "MissingParent" | "UnknownParent" | "SelfParent" | "Cycle" | "UnreachableNode" | "NonFiniteNumber" | "InvalidLengthUnit" | "InvalidZ" | "InvalidVariantCondition" | "NegativeSize" | "NegativeGap" | "NegativePadding" | "InvalidAnchorHorizontal" | "InvalidAnchorVertical" | "NegativeResolvedSize" | "FixedFrameWithoutArranger" | "FillFrameWithoutArranger" | "InvalidFillWeight" | "StackChildMustBeFixed" | "StackContentNegative" | "StackOverflow" | "ExpectedStackArrange" | "StackQueryInvalidRange" | "CellFrameWithoutGrid" | "GridChildMustBeCell" | "InvalidGridTrack" | "InvalidGridCell" | "GridContentNegative" | "GridOverflow" | "RootFrameNotRoot" | "RootFrameWithoutRoot" | "IncompatibleLayouts" | "GuideTargetNotFound" | "GuideSelfReference" | "GuideReferenceCycle" | "GuideInvalidEdgeForAxis" | "GuideTooManyReferencesPerAxis" | "InvalidGuideFrame" | "GuideTargetUnresolved" | "InvalidViewport" | "DuplicateViewportKey" | "UnknownViewportKey" | "InvalidScreen" | "DuplicateScreenKey" | "UnknownScreenKey";
 declare class MachinaLayoutError extends Error {
     readonly code: MachinaLayoutErrorCode;
     constructor(code: MachinaLayoutErrorCode, message: string);
@@ -141,6 +27,8 @@ declare function applyOffset(rect: Rect, parentRect: Rect, offset?: OffsetSpec):
 
 declare function compileLayoutRows(rows: LayoutRow[]): LayoutDocument;
 
+declare function selectLayoutRowsForRoot(rows: LayoutRow[], rootRect: Rect): LayoutRow[];
+
 declare function resolveFrame(parent: Rect, frame: FrameSpec): Rect;
 
 declare function resolveLayoutDocument(document: LayoutDocument, rootRect: Rect): ResolvedLayoutDocument;
@@ -153,117 +41,47 @@ declare function flattenResolvedTree(tree: ResolvedLayoutTree): ResolvedLayoutNo
 
 declare function formatRect(rect: Rect): string;
 
-type MachinaSlotProps<TViewData = unknown, TNodeData = unknown> = {
+type StackChildMetric = {
     id: NodeId;
     rect: Rect;
-    debugLabel?: string;
-    node: ResolvedLayoutNode;
-    viewKey?: string;
-    viewData?: TViewData;
-    nodeData?: TNodeData;
-};
-type MachinaReactViewProps = {
-    layout: ResolvedLayoutDocument;
-    views?: Record<string, React.ComponentType<MachinaSlotProps>>;
-    viewData?: Record<string, unknown>;
-    nodeData?: Record<NodeId, unknown>;
-    className?: string;
-    style?: React.CSSProperties;
-    nodeClassName?: string;
-    debug?: boolean;
-    nodeContainment?: "none" | "layout-paint" | "strict";
-    nodeContentVisibility?: "none" | "auto";
-    nodeContainIntrinsicSize?: string;
-};
-declare function MachinaReactView(props: MachinaReactViewProps): React.JSX.Element;
-
-type MachinaTextSource = {
-    kind: "plain";
-    text: string;
-} | {
-    kind: "machina-text";
-    text: string;
-};
-type MachinaTextVariant = "body" | "label" | "caption" | "title" | "mono";
-type MachinaTextWrap = "word" | "none";
-type MachinaTextOverflow = "clip" | "ellipsis" | "scroll";
-type MachinaTextAlign = "start" | "center" | "end";
-type MachinaTextLeading = "tight" | "normal" | "loose" | number;
-type MachinaTextVerticalAlign = "top" | "center" | "bottom";
-type MachinaTextSpec = {
-    kind: "text";
-    source: MachinaTextSource;
-    variant?: MachinaTextVariant;
-    wrap?: MachinaTextWrap;
-    overflow?: MachinaTextOverflow;
-    align?: MachinaTextAlign;
-    leading?: MachinaTextLeading;
-    blockGap?: number;
-    listGap?: number;
-    valign?: MachinaTextVerticalAlign;
-};
-type MachinaTextDocument = {
-    blocks: MachinaTextBlock[];
-};
-type MachinaTextBlock = {
-    kind: "paragraph";
-    inline: MachinaInline[];
-} | {
-    kind: "bulletList";
-    items: MachinaBulletItem[];
-};
-type MachinaBulletItem = {
-    inline: MachinaInline[];
-    children?: MachinaBulletItem[];
-};
-type MachinaInline = {
-    kind: "text";
-    text: string;
-} | {
-    kind: "strong";
-    children: MachinaInline[];
-} | {
-    kind: "emphasis";
-    children: MachinaInline[];
-} | {
-    kind: "code";
-    text: string;
-} | {
-    kind: "link";
-    href: string;
-    children: MachinaInline[];
-};
-type MachinaTextDiagnosticLevel = "error" | "warning";
-type MachinaTextDiagnosticCode = "unsupported_syntax" | "heading_forbidden" | "max_list_depth_exceeded" | "malformed_link" | "unclosed_inline" | "invalid_escape";
-type MachinaTextDiagnostic = {
-    code: MachinaTextDiagnosticCode;
-    message: string;
-    index: number;
-    length: number;
-    line: number;
-    column: number;
-    level: MachinaTextDiagnosticLevel;
-};
-type ParseMachinaTextResult = {
-    ok: boolean;
-    document: MachinaTextDocument;
-    diagnostics: MachinaTextDiagnostic[];
-};
-
-declare function parseMachinaTextInline(text: string): {
-    inline: MachinaInline[];
-    diagnostics: MachinaTextDiagnostic[];
-};
-declare function parseMachinaText(source: MachinaTextSource | string): ParseMachinaTextResult;
-
-type MachinaTextViewProps = {
-    text: MachinaTextSpec | MachinaTextSource | MachinaTextDocument | string;
-    className?: string;
-    style?: React.CSSProperties;
-    linkTarget?: React.HTMLAttributeAnchorTarget;
-    onLinkClick?: (href: string, event: React.MouseEvent<HTMLAnchorElement>) => void;
-    showDiagnostics?: boolean;
+    mainStart: number;
+    mainEnd: number;
+    mainSize: number;
+    crossStart: number;
+    crossEnd: number;
+    crossSize: number;
+    frameKind: FrameSpec["kind"];
+    z?: number;
+    layer?: LayerName;
 };
-declare function MachinaTextView(props: MachinaTextViewProps): React.JSX.Element;
-
-export { type AbsoluteFrame, type AnchorFrame, type ArrangeSpec, type EdgeInsets, type FillFrame, type FixedFrame, type FrameSpec, type LayoutDocument, type LayoutNode, type LayoutRow, type MachinaBulletItem, type MachinaInline, MachinaLayoutError, type MachinaLayoutErrorCode, MachinaReactView, type MachinaReactViewProps, type MachinaSlotProps, type MachinaTextAlign, type MachinaTextBlock, type MachinaTextDiagnostic, type MachinaTextDiagnosticCode, type MachinaTextDiagnosticLevel, type MachinaTextDocument, type MachinaTextLeading, type MachinaTextOverflow, type MachinaTextSource, type MachinaTextSpec, type MachinaTextVariant, type MachinaTextVerticalAlign, MachinaTextView, type MachinaTextViewProps, type MachinaTextWrap, type NodeId, type OffsetSpec, type ParseMachinaTextResult, type Rect, type ResolvedLayoutDocument, type ResolvedLayoutNode, type ResolvedLayoutTree, type RootFrame, type StackAlign, type StackArrange, type StackAxis, type StackJustify, type UiLength, applyOffset, assertFiniteNumber, assertNonNegativeGap, assertNonNegativePadding, assertNonNegativeSize, compileLayoutRows, flattenResolvedTree, formatRect, normalizePadding, parseMachinaText, parseMachinaTextInline, resolveFrame, resolveLayoutDocument, resolveLayoutRows, resolveUiLength, toResolvedTree };
+type StackMainAxisMetrics = {
+    parentId: NodeId;
+    axis: StackAxis;
+    parentRect: Rect;
+    contentRect: Rect;
+    padding: EdgeInsets;
+    gap: number;
+    childIds: NodeId[];
+    childMetrics: StackChildMetric[];
+    contentMainSize: number;
+    contentCrossSize: number;
+    totalChildMainSize: number;
+    totalGapSize: number;
+    usedMainSize: number;
+    unusedMainSize: number;
+};
+declare function getArrangeContentRect(parentRect: Rect, arrange?: ArrangeSpec): Rect;
+declare function getStackContentRect(layout: ResolvedLayoutDocument, parentId: NodeId): Rect;
+declare function getStackMainAxisMetrics(layout: ResolvedLayoutDocument, parentId: NodeId): StackMainAxisMetrics;
+declare function getStackChildRects(layout: ResolvedLayoutDocument, parentId: NodeId): Record<NodeId, Rect>;
+declare function getRemainingStackRect(layout: ResolvedLayoutDocument, options: {
+    parentId: NodeId;
+    afterChildren?: NodeId[];
+    beforeChildren?: NodeId[];
+}): Rect;
+
+declare function lerpNumber(a: number, b: number, t: number): number;
+declare function lerpRect(a: Rect, b: Rect, t: number): Rect;
+declare function lerpResolvedLayouts(a: ResolvedLayoutDocument, b: ResolvedLayoutDocument, t: number): ResolvedLayoutDocument;
+
+export { ArrangeSpec, EdgeInsets, FrameSpec, LayerName, LayoutDocument, LayoutRow, MachinaLayoutError, type MachinaLayoutErrorCode, NodeId, OffsetSpec, Rect, ResolvedLayoutDocument, ResolvedLayoutNode, ResolvedLayoutTree, StackAxis, type StackChildMetric, type StackMainAxisMetrics, UiLength, applyOffset, assertFiniteNumber, assertNonNegativeGap, assertNonNegativePadding, assertNonNegativeSize, compileLayoutRows, flattenResolvedTree, formatRect, getArrangeContentRect, getRemainingStackRect, getStackChildRects, getStackContentRect, getStackMainAxisMetrics, lerpNumber, lerpRect, lerpResolvedLayouts, normalizePadding, resolveFrame, resolveLayoutDocument, resolveLayoutRows, resolveUiLength, selectLayoutRowsForRoot, toResolvedTree };