machinalayout 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,6 +1,14 @@
+import {
+  createViewportMatrix,
+  defineMachinaScreens,
+  defineMachinaViewports,
+  expandScreenViewportTasks,
+  getMachinaViewport,
+  slugMachinaArtifactName
+} from "./chunk-33CKBEJH.js";
 import {
   MachinaReactView
-} from "./chunk-HU6XYOH7.js";
+} from "./chunk-MSTBFD7H.js";
 import "./chunk-RJYRJ3LD.js";
 import {
   MachinaTextView
@@ -9,10 +17,14 @@ import {
   parseMachinaText,
   parseMachinaTextInline
 } from "./chunk-BJOQRPPX.js";
+import "./chunk-ZIGW44D5.js";
 import {
-  MachinaLayoutError,
   toResolvedTree
-} from "./chunk-TR24ERZT.js";
+} from "./chunk-SVWYWI7I.js";
+import {
+  MachinaLayoutError
+} from "./chunk-VREK57S3.js";
+import "./chunk-2ZQ2RFFI.js";
 
 // src/validation.ts
 function assertFiniteNumber(value, fieldName) {
@@ -947,6 +959,149 @@ function formatRect(rect) {
   return `x=${rect.x} y=${rect.y} w=${rect.width} h=${rect.height}`;
 }
 
+// src/stackGeometry.ts
+function copyRect(rect) {
+  return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+}
+function applyPadding(parentRect, padding) {
+  return {
+    x: parentRect.x + padding.left,
+    y: parentRect.y + padding.top,
+    width: parentRect.width - padding.left - padding.right,
+    height: parentRect.height - padding.top - padding.bottom
+  };
+}
+function assertContentNonNegative(contentRect, code) {
+  if (contentRect.width < 0 || contentRect.height < 0) {
+    throw new MachinaLayoutError(
+      code,
+      `${code === "StackContentNegative" ? "stack" : "grid"} content size cannot be negative after applying padding`
+    );
+  }
+}
+function requireNode(layout, nodeId) {
+  const node = layout.nodes[nodeId];
+  if (!node) throw new MachinaLayoutError("InvalidId", `node id not found: ${nodeId}`);
+  return node;
+}
+function requireStackArrange(layout, parentId) {
+  const parent = requireNode(layout, parentId);
+  if (parent.arrange?.kind !== "stack") {
+    throw new MachinaLayoutError(
+      "ExpectedStackArrange",
+      `expected stack arrange for node: ${parentId}`
+    );
+  }
+  return parent.arrange;
+}
+function getArrangeContentRect(parentRect, arrange) {
+  if (!arrange) return copyRect(parentRect);
+  if (arrange.kind === "stack") {
+    const contentRect = applyPadding(parentRect, normalizePadding(arrange.padding));
+    assertContentNonNegative(contentRect, "StackContentNegative");
+    return contentRect;
+  }
+  if (arrange.kind === "grid") {
+    const contentRect = applyPadding(parentRect, normalizePadding(arrange.padding));
+    assertContentNonNegative(contentRect, "GridContentNegative");
+    return contentRect;
+  }
+  return copyRect(parentRect);
+}
+function getStackContentRect(layout, parentId) {
+  const parent = requireNode(layout, parentId);
+  const arrange = requireStackArrange(layout, parentId);
+  return getArrangeContentRect(parent.rect, arrange);
+}
+function getStackMainAxisMetrics(layout, parentId) {
+  const parent = requireNode(layout, parentId);
+  const arrange = requireStackArrange(layout, parentId);
+  const contentRect = getArrangeContentRect(parent.rect, arrange);
+  const isHorizontal = arrange.axis === "horizontal";
+  const childIds = [...layout.children[parentId] ?? []];
+  const childMetrics = childIds.map((id) => {
+    const child = requireNode(layout, id);
+    const rect = copyRect(child.rect);
+    const mainStart = isHorizontal ? rect.x - contentRect.x : rect.y - contentRect.y;
+    const mainSize = isHorizontal ? rect.width : rect.height;
+    const crossStart = isHorizontal ? rect.y - contentRect.y : rect.x - contentRect.x;
+    const crossSize = isHorizontal ? rect.height : rect.width;
+    return {
+      id,
+      rect,
+      mainStart,
+      mainEnd: mainStart + mainSize,
+      mainSize,
+      crossStart,
+      crossEnd: crossStart + crossSize,
+      crossSize,
+      frameKind: child.frame.kind,
+      z: child.z,
+      layer: child.layer
+    };
+  });
+  const contentMainSize = isHorizontal ? contentRect.width : contentRect.height;
+  const contentCrossSize = isHorizontal ? contentRect.height : contentRect.width;
+  const totalChildMainSize = childMetrics.reduce((sum, metric) => sum + metric.mainSize, 0);
+  const totalGapSize = (arrange.gap ?? 0) * Math.max(0, childMetrics.length - 1);
+  const usedMainSize = totalChildMainSize + totalGapSize;
+  return {
+    parentId,
+    axis: arrange.axis,
+    parentRect: copyRect(parent.rect),
+    contentRect,
+    padding: normalizePadding(arrange.padding),
+    gap: arrange.gap ?? 0,
+    childIds,
+    childMetrics,
+    contentMainSize,
+    contentCrossSize,
+    totalChildMainSize,
+    totalGapSize,
+    usedMainSize,
+    unusedMainSize: contentMainSize - usedMainSize
+  };
+}
+function getStackChildRects(layout, parentId) {
+  requireStackArrange(layout, parentId);
+  const rects = {};
+  for (const childId of layout.children[parentId] ?? []) {
+    rects[childId] = copyRect(requireNode(layout, childId).rect);
+  }
+  return rects;
+}
+function getRemainingStackRect(layout, options) {
+  const metrics = getStackMainAxisMetrics(layout, options.parentId);
+  const byId = new Map(metrics.childMetrics.map((metric) => [metric.id, metric]));
+  const after = options.afterChildren ?? [];
+  const before = options.beforeChildren ?? [];
+  const start = after.length === 0 ? 0 : Math.max(...after.map((id) => requireStackMetric(byId, id).mainEnd));
+  const end = before.length === 0 ? metrics.contentMainSize : Math.min(...before.map((id) => requireStackMetric(byId, id).mainStart));
+  const size = end - start;
+  if (size < 0) {
+    throw new MachinaLayoutError(
+      "StackQueryInvalidRange",
+      `remaining stack interval is negative for parent: ${options.parentId}`
+    );
+  }
+  return metrics.axis === "horizontal" ? {
+    x: metrics.contentRect.x + start,
+    y: metrics.contentRect.y,
+    width: size,
+    height: metrics.contentRect.height
+  } : {
+    x: metrics.contentRect.x,
+    y: metrics.contentRect.y + start,
+    width: metrics.contentRect.width,
+    height: size
+  };
+}
+function requireStackMetric(metrics, childId) {
+  const metric = metrics.get(childId);
+  if (!metric) throw new MachinaLayoutError("InvalidId", `stack child id not found: ${childId}`);
+  return metric;
+}
+
 // src/lerp.ts
 function assertFiniteNumber2(value) {
   if (!Number.isFinite(value)) {
@@ -1056,8 +1211,18 @@ export {
   assertNonNegativePadding,
   assertNonNegativeSize,
   compileLayoutRows,
+  createViewportMatrix,
+  defineMachinaScreens,
+  defineMachinaViewports,
+  expandScreenViewportTasks,
   flattenResolvedTree,
   formatRect,
+  getArrangeContentRect,
+  getMachinaViewport,
+  getRemainingStackRect,
+  getStackChildRects,
+  getStackContentRect,
+  getStackMainAxisMetrics,
   lerpNumber,
   lerpRect,
   lerpResolvedLayouts,
@@ -1069,5 +1234,6 @@ export {
   resolveLayoutRows,
   resolveUiLength,
   selectLayoutRowsForRoot,
+  slugMachinaArtifactName,
   toResolvedTree
 };

package/dist/inspect/index.d.ts

@@ -0,0 +1,8 @@
+import { S as SummarizeMachinaDomOptions, M as MachinaDomSummary } from '../types-bJlg6wno.js';
+export { a as MachinaDomSummaryNode } from '../types-bJlg6wno.js';
+import '../types-CYgsjDai.js';
+
+type DomRoot = ParentNode | Element | Document;
+declare function summarizeMachinaDom(rootOrOptions?: DomRoot | SummarizeMachinaDomOptions): MachinaDomSummary;
+
+export { MachinaDomSummary, SummarizeMachinaDomOptions, summarizeMachinaDom };

package/dist/inspect/index.js

@@ -0,0 +1,97 @@
+// src/inspect/summarizeMachinaDom.ts
+var DEFAULT_SELECTOR = "[data-machina-node-id]";
+var DEFAULT_MAX_TEXT_LENGTH = 120;
+function getGlobalDocument() {
+  return typeof document === "undefined" ? void 0 : document;
+}
+function isOptions(value) {
+  if (value === void 0 || value === null || typeof value !== "object") return false;
+  return "root" in value || "selector" in value || "includeTextExcerpt" in value || "includeA11y" in value || "generatedAt" in value || "maxTextLength" in value || "includeEmptyNodes" in value;
+}
+function readOptionalAttribute(element, name) {
+  const value = element.getAttribute(name);
+  return value === null || value === "" ? void 0 : value;
+}
+function rectFromElement(element) {
+  const rect = element.getBoundingClientRect();
+  return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+}
+function textExcerpt(element, maxLength) {
+  const normalized = (element.textContent ?? "").replace(/\s+/g, " ").trim();
+  if (normalized === "") return void 0;
+  return normalized.length > maxLength ? normalized.slice(0, maxLength) : normalized;
+}
+function canMatchRoot(root) {
+  return typeof root.matches === "function";
+}
+function queryMatchingElements(root, selector) {
+  const matches = Array.from(root.querySelectorAll(selector));
+  if (canMatchRoot(root) && root.matches(selector)) return [root, ...matches];
+  return matches;
+}
+function nearestMatchingAncestor(element, selected, root) {
+  let parent = element.parentElement;
+  while (parent) {
+    if (selected.has(parent)) return parent;
+    if (parent === root) return void 0;
+    parent = parent.parentElement;
+  }
+  return void 0;
+}
+function makeSummaryNode(element, options) {
+  const node = {
+    tagName: element.tagName.toLowerCase(),
+    rect: rectFromElement(element),
+    children: []
+  };
+  const nodeId = readOptionalAttribute(element, "data-machina-node-id");
+  const view = readOptionalAttribute(element, "data-machina-view");
+  const slot = readOptionalAttribute(element, "data-machina-slot");
+  const debugLabel = readOptionalAttribute(element, "data-machina-debug-label");
+  const layer = readOptionalAttribute(element, "data-machina-layer");
+  if (nodeId !== void 0) node.nodeId = nodeId;
+  if (view !== void 0) node.view = view;
+  if (slot !== void 0) node.slot = slot;
+  if (debugLabel !== void 0) node.debugLabel = debugLabel;
+  if (layer !== void 0) node.layer = layer;
+  if (options.includeA11y) {
+    const role = readOptionalAttribute(element, "role");
+    const ariaLabel = readOptionalAttribute(element, "aria-label");
+    if (role !== void 0) node.role = role;
+    if (ariaLabel !== void 0) node.ariaLabel = ariaLabel;
+  }
+  if (options.includeTextExcerpt) {
+    const excerpt = textExcerpt(element, options.maxTextLength);
+    if (excerpt !== void 0) node.textExcerpt = excerpt;
+  }
+  return node;
+}
+function summarizeMachinaDom(rootOrOptions) {
+  const options = isOptions(rootOrOptions) ? rootOrOptions : { root: rootOrOptions };
+  const selector = options.selector ?? DEFAULT_SELECTOR;
+  const root = options.root ?? getGlobalDocument();
+  const summary = { schemaVersion: 1, rootSelector: selector, nodes: [] };
+  if (options.generatedAt !== void 0) summary.generatedAt = options.generatedAt;
+  if (root === void 0 || typeof root.querySelectorAll !== "function") return summary;
+  const elements = queryMatchingElements(root, selector);
+  const selected = new Set(elements);
+  const nodeByElement = /* @__PURE__ */ new Map();
+  const nodeOptions = {
+    includeTextExcerpt: options.includeTextExcerpt ?? false,
+    includeA11y: options.includeA11y ?? false,
+    maxTextLength: options.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH
+  };
+  for (const element of elements) nodeByElement.set(element, makeSummaryNode(element, nodeOptions));
+  for (const element of elements) {
+    const node = nodeByElement.get(element);
+    if (!node) continue;
+    const parent = nearestMatchingAncestor(element, selected, root);
+    const parentNode = parent === void 0 ? void 0 : nodeByElement.get(parent);
+    if (parentNode) parentNode.children.push(node);
+    else summary.nodes.push(node);
+  }
+  return summary;
+}
+export {
+  summarizeMachinaDom
+};

package/dist/react/index.d.ts

@@ -1,33 +1,6 @@
-import React from 'react';
-import { b as ResolvedLayoutDocument, N as NodeId, R as Rect, a as ResolvedLayoutNode } from '../types-BudfpzZX.js';
-
-type MachinaSlotProps<TViewData = unknown, TNodeData = unknown> = {
-    id: NodeId;
-    rect: Rect;
-    debugLabel?: string;
-    node: ResolvedLayoutNode;
-    viewKey?: string;
-    viewData?: TViewData;
-    nodeData?: TNodeData;
-};
-type MachinaRenderLayer = {
-    z: number;
-};
-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;
-    layers?: Record<string, MachinaRenderLayer>;
-    defaultLayer?: string;
-};
-declare function MachinaReactView(props: MachinaReactViewProps): React.JSX.Element;
-
-export { MachinaReactView, type MachinaReactViewProps, type MachinaSlotProps };
+export { U as UseDeusMachineResult, u as useDeusMachine } from '../useDeusMachine-2w2u_dki.js';
+export { M as MachinaReactDebugOverlayOptions, a as MachinaReactView, b as MachinaReactViewProps, c as MachinaSlotProps } from '../MachinaReactView-Bau5bErA.js';
+import '../types-CWaup8Z6.js';
+import 'react';
+import '../debugOverlay-fWLv1cS7.js';
+import '../types-CYgsjDai.js';

package/dist/react/index.js

@@ -1,7 +1,13 @@
 import {
   MachinaReactView
-} from "../chunk-HU6XYOH7.js";
-import "../chunk-TR24ERZT.js";
+} from "../chunk-MSTBFD7H.js";
+import {
+  useDeusMachine
+} from "../chunk-ZIGW44D5.js";
+import "../chunk-SVWYWI7I.js";
+import "../chunk-VREK57S3.js";
+import "../chunk-2ZQ2RFFI.js";
 export {
-  MachinaReactView
+  MachinaReactView,
+  useDeusMachine
 };

package/dist/react-native/index.d.ts

@@ -1,6 +1,8 @@
+export { U as UseDeusMachineResult, u as useDeusMachine } from '../useDeusMachine-2w2u_dki.js';
 import React from 'react';
 import { StyleProp, ViewStyle } from 'react-native';
-import { N as NodeId, R as Rect, a as ResolvedLayoutNode, b as ResolvedLayoutDocument } from '../types-BudfpzZX.js';
+import { N as NodeId, a as Rect, b as ResolvedLayoutNode, R as ResolvedLayoutDocument } from '../types-CYgsjDai.js';
+import '../types-CWaup8Z6.js';
 
 type MachinaNativeSlotProps<TViewData = unknown, TNodeData = unknown> = {
     id: NodeId;

package/dist/react-native/index.js

@@ -1,6 +1,11 @@
+import {
+  useDeusMachine
+} from "../chunk-ZIGW44D5.js";
 import {
   toResolvedTree
-} from "../chunk-TR24ERZT.js";
+} from "../chunk-SVWYWI7I.js";
+import "../chunk-VREK57S3.js";
+import "../chunk-2ZQ2RFFI.js";
 
 // src/react-native/MachinaReactNativeView.tsx
 import React from "react";
@@ -79,5 +84,6 @@ function MachinaReactNativeView(props) {
   );
 }
 export {
-  MachinaReactNativeView
+  MachinaReactNativeView,
+  useDeusMachine
 };

package/dist/screenCatalog-ZjonGiOi.d.ts

@@ -0,0 +1,46 @@
+type MachinaViewport = {
+    key: string;
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+    label?: string;
+    tags?: readonly string[];
+};
+type MachinaViewportMatrix = readonly MachinaViewport[];
+type MachinaScreen = {
+    key: string;
+    route: string;
+    fixture?: string;
+    viewports?: readonly string[];
+    tags?: readonly string[];
+    title?: string;
+    metadata?: Record<string, unknown>;
+};
+type MachinaScreenCatalog = {
+    screens: Record<string, MachinaScreen>;
+    order: string[];
+};
+type MachinaScreenViewportTask = {
+    key: string;
+    screenKey: string;
+    viewportKey: string;
+    route: string;
+    fixture?: string;
+    viewport: MachinaViewport;
+    screen: MachinaScreen;
+    tags: readonly string[];
+    artifactBaseName: string;
+};
+type ExpandOptions = {
+    screenKeys?: readonly string[];
+    viewportKeys?: readonly string[];
+    tags?: readonly string[];
+};
+declare function defineMachinaViewports(viewports: readonly MachinaViewport[]): MachinaViewportMatrix;
+declare function createViewportMatrix(preset?: "standard-responsive" | "desktop-only" | "mobile-first"): MachinaViewportMatrix;
+declare function defineMachinaScreens(screens: readonly MachinaScreen[]): MachinaScreenCatalog;
+declare function slugMachinaArtifactName(input: string): string;
+declare function getMachinaViewport(viewports: MachinaViewportMatrix, key: string): MachinaViewport;
+declare function expandScreenViewportTasks(catalog: MachinaScreenCatalog, viewports: MachinaViewportMatrix, options?: ExpandOptions): MachinaScreenViewportTask[];
+
+export { type MachinaViewport as M, type MachinaScreenViewportTask as a, type MachinaScreen as b, type MachinaScreenCatalog as c, type MachinaViewportMatrix as d, createViewportMatrix as e, defineMachinaScreens as f, defineMachinaViewports as g, expandScreenViewportTasks as h, getMachinaViewport as i, slugMachinaArtifactName as s };

package/dist/types-CWaup8Z6.d.ts

@@ -0,0 +1,92 @@
+declare class DeusMachinaError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+type UtilityScore<TContext> = number | ((context: TContext) => number);
+type UtilityCandidate<TContext, TKey extends string = string> = {
+    key: TKey;
+    when?: (context: TContext) => boolean;
+    score: UtilityScore<TContext>;
+    reason?: string | ((context: TContext) => string);
+};
+type UtilityCandidateResult<TKey extends string = string> = {
+    key: TKey;
+    eligible: boolean;
+    score: number;
+    index: number;
+    reason?: string;
+};
+type UtilityJudgment<TKey extends string = string> = {
+    selected: UtilityCandidateResult<TKey> | null;
+    candidates: UtilityCandidateResult<TKey>[];
+};
+type JudgeUtilityOptions<TKey extends string = string> = {
+    previousKey?: TKey;
+    hysteresis?: number;
+};
+type DeusStatePath = readonly string[];
+type DeusEvent = {
+    type: string;
+};
+type DeusAction<TBoard, TEvent extends DeusEvent> = (board: TBoard, event: TEvent) => void;
+type DeusStateRow<TBoard, TEvent extends DeusEvent> = {
+    path: DeusStatePath;
+    onEnter?: DeusAction<TBoard, TEvent>;
+    onExit?: DeusAction<TBoard, TEvent>;
+};
+type DeusUtilityTransitionCandidate<TBoard, TEvent extends DeusEvent, TKey extends string = string> = {
+    key: TKey;
+    when?: (board: TBoard, event: TEvent) => boolean;
+    score: number | ((board: TBoard, event: TEvent) => number);
+    do?: DeusAction<TBoard, TEvent>;
+    reason?: string | ((board: TBoard, event: TEvent) => string);
+};
+type DeusTransitionRow<TBoard, TEvent extends DeusEvent> = {
+    key: string;
+    from: DeusStatePath;
+    event?: TEvent["type"];
+    to?: DeusStatePath | ((board: TBoard, event: TEvent) => DeusStatePath);
+    when?: (board: TBoard, event: TEvent) => boolean;
+    score?: number | ((board: TBoard, event: TEvent) => number);
+    do?: DeusAction<TBoard, TEvent>;
+    reason?: string | ((board: TBoard, event: TEvent) => string);
+    utility?: readonly DeusUtilityTransitionCandidate<TBoard, TEvent>[];
+    hysteresis?: {
+        previous: (board: TBoard) => string | undefined;
+        margin: number;
+    };
+};
+type DeusMachine<TBoard, TEvent extends DeusEvent> = {
+    initial: DeusStatePath;
+    states: readonly DeusStateRow<TBoard, TEvent>[];
+    transitions: readonly DeusTransitionRow<TBoard, TEvent>[];
+};
+type DeusSnapshot<TBoard> = {
+    state: DeusStatePath;
+    board: TBoard;
+    stepIndex: number;
+};
+type DeusTransitionTrace = {
+    key: string;
+    from: DeusStatePath;
+    to?: DeusStatePath;
+    event?: string;
+    eligible: boolean;
+    score: number;
+    index: number;
+    reason?: string;
+    utility?: UtilityJudgment<string>;
+};
+type DeusStepTrace = {
+    stateBefore: DeusStatePath;
+    stateAfter: DeusStatePath;
+    event: string;
+    selectedTransition?: DeusTransitionTrace;
+    transitions: DeusTransitionTrace[];
+};
+type DeusStepResult<TBoard> = {
+    snapshot: DeusSnapshot<TBoard>;
+    trace: DeusStepTrace;
+};
+
+export { type DeusEvent as D, type JudgeUtilityOptions as J, type UtilityCandidate as U, type DeusSnapshot as a, type DeusStatePath as b, type DeusStepResult as c, type DeusStepTrace as d, type DeusMachine as e, type UtilityJudgment as f, type DeusAction as g, DeusMachinaError as h, type DeusStateRow as i, type DeusTransitionRow as j, type DeusTransitionTrace as k, type DeusUtilityTransitionCandidate as l, type UtilityCandidateResult as m, type UtilityScore as n };

package/dist/{types-BudfpzZX.d.ts → types-CYgsjDai.d.ts}

@@ -181,4 +181,4 @@ type ResolvedLayoutTree = {
     children: ResolvedLayoutTree[];
 };
 
-export type { AbsoluteFrame as A, CellFrame as C, EdgeInsets as E, FrameSpec as F, GridArrange as G, LayoutRow as L, NodeId as N, OffsetSpec as O, Rect as R, StackAlign as S, UiLength as U, ResolvedLayoutNode as a, ResolvedLayoutDocument as b, LayoutDocument as c, ResolvedLayoutTree as d, AnchorFrame as e, ArrangeSpec as f, EdgeRef as g, FillFrame as h, FixedFrame as i, GridTrack as j, GuideFrame as k, GuideLength as l, LayerName as m, LayoutNode as n, LayoutRowVariant as o, LayoutVariantCondition as p, RectEdge as q, RootFrame as r, StackArrange as s, StackAxis as t, StackJustify as u };
+export type { ArrangeSpec as A, CellFrame as C, EdgeInsets as E, FrameSpec as F, GridArrange as G, LayoutRow as L, NodeId as N, OffsetSpec as O, ResolvedLayoutDocument as R, StackAxis as S, UiLength as U, Rect as a, ResolvedLayoutNode as b, LayoutDocument as c, ResolvedLayoutTree as d, LayerName as e, AbsoluteFrame as f, AnchorFrame as g, EdgeRef as h, FillFrame as i, FixedFrame as j, GridTrack as k, GuideFrame as l, GuideLength as m, LayoutNode as n, LayoutRowVariant as o, LayoutVariantCondition as p, RectEdge as q, RootFrame as r, StackAlign as s, StackArrange as t, StackJustify as u };

package/dist/types-bJlg6wno.d.ts

@@ -0,0 +1,32 @@
+import { a as Rect } from './types-CYgsjDai.js';
+
+type MachinaDomSummaryNode = {
+    nodeId?: string;
+    view?: string;
+    slot?: string;
+    debugLabel?: string;
+    layer?: string;
+    tagName: string;
+    role?: string;
+    ariaLabel?: string;
+    textExcerpt?: string;
+    rect: Rect;
+    children: MachinaDomSummaryNode[];
+};
+type MachinaDomSummary = {
+    schemaVersion: 1;
+    rootSelector?: string;
+    generatedAt?: string;
+    nodes: MachinaDomSummaryNode[];
+};
+type SummarizeMachinaDomOptions = {
+    root?: ParentNode | Element | Document;
+    selector?: string;
+    includeTextExcerpt?: boolean;
+    includeA11y?: boolean;
+    maxTextLength?: number;
+    includeEmptyNodes?: boolean;
+    generatedAt?: string;
+};
+
+export type { MachinaDomSummary as M, SummarizeMachinaDomOptions as S, MachinaDomSummaryNode as a };

package/dist/useDeusMachine-2w2u_dki.d.ts

@@ -0,0 +1,14 @@
+import { D as DeusEvent, a as DeusSnapshot, b as DeusStatePath, c as DeusStepResult, d as DeusStepTrace, e as DeusMachine } from './types-CWaup8Z6.js';
+
+type UseDeusMachineResult<TBoard, TEvent extends DeusEvent> = {
+    snapshot: DeusSnapshot<TBoard>;
+    board: TBoard;
+    state: DeusStatePath;
+    dispatch: (event: TEvent) => DeusStepResult<TBoard>;
+    lastTrace: DeusStepTrace | null;
+    reset: (board?: TBoard | (() => TBoard)) => void;
+};
+type InitialBoard<TBoard> = TBoard | (() => TBoard);
+declare function useDeusMachine<TBoard, TEvent extends DeusEvent>(machine: DeusMachine<TBoard, TEvent>, initialBoard: InitialBoard<TBoard>): UseDeusMachineResult<TBoard, TEvent>;
+
+export { type UseDeusMachineResult as U, useDeusMachine as u };

package/dist/vue/index.d.ts

@@ -1,6 +1,18 @@
 import * as vue from 'vue';
-import { PropType, Component, StyleValue } from 'vue';
-import { N as NodeId, R as Rect, a as ResolvedLayoutNode, b as ResolvedLayoutDocument } from '../types-BudfpzZX.js';
+import { Ref, ComputedRef, PropType, Component, StyleValue } from 'vue';
+import { D as DeusEvent, a as DeusSnapshot, b as DeusStatePath, c as DeusStepResult, d as DeusStepTrace, e as DeusMachine } from '../types-CWaup8Z6.js';
+import { N as NodeId, a as Rect, b as ResolvedLayoutNode, R as ResolvedLayoutDocument } from '../types-CYgsjDai.js';
+
+type UseVueDeusMachineResult<TBoard, TEvent extends DeusEvent> = {
+    snapshot: Ref<DeusSnapshot<TBoard>>;
+    board: ComputedRef<TBoard>;
+    state: ComputedRef<DeusStatePath>;
+    dispatch: (event: TEvent) => DeusStepResult<TBoard>;
+    lastTrace: Ref<DeusStepTrace | null>;
+    reset: (board?: TBoard | (() => TBoard)) => void;
+};
+type InitialBoard<TBoard> = TBoard | (() => TBoard);
+declare function useDeusMachine<TBoard, TEvent extends DeusEvent>(machine: DeusMachine<TBoard, TEvent>, initialBoard: InitialBoard<TBoard>): UseVueDeusMachineResult<TBoard, TEvent>;
 
 type MachinaVueSlotProps<TViewData = unknown, TNodeData = unknown> = {
     id: NodeId;
@@ -170,4 +182,4 @@ declare const MachinaVueView: vue.DefineComponent<vue.ExtractPropTypes<{
     nodeContainIntrinsicSize: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-export { type MachinaVueLayer, type MachinaVueSlotProps, MachinaVueView, type MachinaVueViewProps };
+export { type MachinaVueLayer, type MachinaVueSlotProps, MachinaVueView, type MachinaVueViewProps, type UseVueDeusMachineResult, useDeusMachine };