@pygmalionjs/pygmalion 0.13.0 → 0.15.0

package/dist-lib/types/workspace/edit/rasterExport.d.ts

@@ -0,0 +1,5 @@
+import { type RasterExportRenderer, type RasterExportRequest } from '../../document/exportSettings.js';
+/** The same supported SVG geometry supplies browser raster output; unsupported visuals stay explicit. */
+export declare function rasterExportSvg(request: RasterExportRequest): string;
+/** Explicit browser renderer for supported geometry. It never captures a page or fetches external resources. */
+export declare const renderDesignRaster: RasterExportRenderer;

package/dist-lib/types/workspace/view/prototypeMotionInterruption.d.ts

@@ -0,0 +1,37 @@
+import type { PrototypeTransition } from '../../document/prototype.js';
+export declare const prototypeMotionProperties: readonly ["transform", "width", "height", "opacity", "backgroundColor", "borderRadius"];
+export type PrototypeMotionProperty = typeof prototypeMotionProperties[number];
+export type PrototypeMotionStyles = Record<PrototypeMotionProperty, string>;
+export interface PrototypeMotionCapture {
+    styles: PrototypeMotionStyles;
+    velocity: Partial<Record<PrototypeMotionProperty, readonly number[]>>;
+}
+export interface PrototypeMotionRecord {
+    element: HTMLElement;
+    animation: Animation;
+    frames: readonly Keyframe[];
+    durationMs: number;
+    easing(progress: number): number;
+}
+/** Mirrors the bounded CSS linear() samples used by the physical spring renderer. */
+export declare function prototypeMotionTiming(transition: PrototypeTransition, durationMs: number): (progress: number) => number;
+/** Reads presentation once. No time seeks, inline-style writes, frame history or DOM mutations. */
+export declare function capturePrototypeMotionStyles(elements: readonly HTMLElement[], records: readonly PrototypeMotionRecord[], drag?: {
+    progress: number;
+    velocity: number;
+} | null): Map<HTMLElement, PrototypeMotionCapture>;
+export interface PrototypeInterruptedTiming {
+    readonly samples: readonly {
+        offset: number;
+        progress: number;
+        velocityResponse: number;
+    }[];
+    readonly initialSlope: number;
+}
+/** One shared timing table per interrupted transition, never one solver per layer/channel. */
+export declare function createPrototypeInterruptedTiming(transition: PrototypeTransition, durationMs: number): PrototypeInterruptedTiming;
+/** Existing computed 2D/px/RGB tracks only. Unsupported values retain explicit diagnostics. */
+export declare function createPrototypeInterruptedFrames(captured: PrototypeMotionCapture, target: Partial<PrototypeMotionStyles>, timing: PrototypeInterruptedTiming): {
+    frames: Keyframe[];
+    unsupported: PrototypeMotionProperty[];
+};

package/dist-lib/types/workspace/view/prototypePlayback.d.ts

@@ -27,9 +27,17 @@ export interface PrototypePlayerOptions extends PrototypeStartOptions {
     /** Effects describe intended links and scrolling; the adapter decides how to execute them. */
     onEffect?(effect: PrototypeEffect): void;
 }
+export interface PrototypeTransitionChange {
+    previous: PrototypePlayerSnapshot;
+    next: PrototypeState;
+    interrupted: boolean;
+    reset: boolean;
+}
 export interface PrototypePlayerController {
     getSnapshot(): PrototypePlayerSnapshot;
     subscribe(listener: () => void): () => void;
+    /** Capture presentation before the old scene is replaced. Exceptions become diagnostics. */
+    subscribeBeforeTransition(listener: (change: PrototypeTransitionChange) => void): () => void;
     dispatch(event: PrototypeEvent): void;
     beginDrag(input: Omit<PrototypeDragStartInput, 'now'>): boolean;
     updateDrag(input: Pick<PrototypeDragStartInput, 'pointerId' | 'point'>): void;

package/dist-lib/types/workspace/view/storyboardCanvas.d.ts

@@ -16,14 +16,25 @@ export interface StoryboardArtboard extends StoryboardBounds {
     screenId: string;
     group: string;
 }
+export interface StoryboardPoint {
+    x: number;
+    y: number;
+}
 export interface StoryboardConnection {
     edge: StoryboardGraphEdge;
     from: StoryboardArtboard;
     to: StoryboardArtboard;
     path: string;
+    points: readonly StoryboardPoint[];
     labelX: number;
     labelY: number;
 }
+export interface StoryboardExternalConnection {
+    edge: StoryboardGraphEdge;
+    frame: StoryboardArtboard;
+    page: PageModel;
+    direction: 'incoming' | 'outgoing';
+}
 export declare const storyboardFlow: (page: PageModel) => string;
 /** Arrange source-sized screens in flow lanes; never rewrite authored page geometry. */
 export declare function layoutStoryboard(pages: readonly PageModel[]): {
@@ -38,5 +49,9 @@ export declare function zoomStoryboard(camera: WorkspaceCamera, point: {
     y: number;
 }, requested: number): WorkspaceCamera;
 export declare function visibleStoryboardFrames(frames: readonly StoryboardArtboard[], camera: WorkspaceCamera, viewport: StoryboardViewport): StoryboardArtboard[];
-/** A line means an authored transition. Layout proximity never creates an edge. */
+/** A line means an authored transition. Routing and proximity never create or reorder an edge. */
 export declare function storyboardConnections(frames: readonly StoryboardArtboard[], graph: StoryboardGraph | null): StoryboardConnection[];
+/** Portals expose real endpoints filtered from the canvas, only when available in the active catalog. */
+export declare function storyboardExternalConnections(frames: readonly StoryboardArtboard[], graph: StoryboardGraph | null, pages: readonly PageModel[]): StoryboardExternalConnection[];
+/** Include connector lanes in Overview without changing the authored artboard layout. */
+export declare function storyboardConnectionBounds(bounds: StoryboardBounds, connections: readonly StoryboardConnection[]): StoryboardBounds;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pygmalionjs/pygmalion",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Code-backed DOM design sandbox and visual QA editor",
   "license": "Apache-2.0",
   "repository": {