@pygmalionjs/pygmalion 0.23.0 → 0.25.0

package/dist-lib/testing.js

@@ -1,5 +1,5 @@
-import { b$ as l, T as u } from "./runtime-DLaOoI2y.js";
-import { br as y, ch as b, ci as E, cj as P, bn as $, aw as T } from "./runtime-DLaOoI2y.js";
+import { c0 as l, T as u } from "./runtime-Dj5sWqho.js";
+import { bs as y, ci as E, cj as P, ck as b, bo as T, aw as $ } from "./runtime-Dj5sWqho.js";
 const v = {
   mirror: ["status", "refresh", "refs"],
   session: ["open", "check", "previewVisual", "applyVisual", "revertVisual"],
@@ -8,7 +8,7 @@ const v = {
   preview: ["artifact", "progress", "catalog"],
   storyboard: ["environment", "sourceUsage", "componentBranches"]
 };
-function h(m = {}, t = {}) {
+function g(m = {}, t = {}) {
   const n = [], d = t.origin ?? "", r = (e) => {
     var a;
     const i = {};
@@ -38,10 +38,10 @@ function h(m = {}, t = {}) {
 }
 export {
   y as EditorRuntimeProvider,
-  b as EditorStore,
-  E as FrozenRoutePreviewView,
-  P as NodeModel,
-  $ as createEditorRuntime,
-  h as createMemoryTransport,
-  T as serializeNode
+  E as EditorStore,
+  P as FrozenRoutePreviewView,
+  b as NodeModel,
+  T as createEditorRuntime,
+  g as createMemoryTransport,
+  $ as serializeNode
 };

package/dist-lib/types/lib.d.ts

@@ -34,7 +34,9 @@ export type { InspectSourceRuntime, SourceWritePolicy, SourceWriteErrorCode } fr
 export { WorkspaceController } from './workspace/controller.js';
 export { createLegacyModeAdapter } from './workspace/legacyModeAdapter.js';
 export type * from './workspace/contracts.js';
-export { createWorkspaceTargetResolver, resolveWorkspaceTarget } from './workspace/configuration.js';
+export { canEditWorkspaceTarget, createWorkspaceTargetResolver, resolveWorkspaceTarget } from './workspace/configuration.js';
+export { screenStateGroup, screenStateLabel } from './workspace/screenStates.js';
+export type { ScreenStateGroup, ScreenStateMember } from './workspace/screenStates.js';
 export type { WorkspaceConfiguration, WorkspaceTargetConfiguration, WorkspaceTargetResolverOptions } from './workspace/configuration.js';
 export { capturedScreenMetadata, screenDocumentFromImport } from './document/screenImport.js';
 export { createCapturedScreenDocumentLoader } from './workspace/capture/capturedScreenDocument.js';

package/dist-lib/types/workspace/ScreenStateSwitch.d.ts

@@ -0,0 +1,17 @@
+import type { EditorRuntime } from '../core/runtime.js';
+import type { PageModel } from '../editor/store.js';
+import type { WorkspaceTarget } from './contracts.js';
+export interface ScreenStateSwitchProps {
+    runtime: EditorRuntime;
+    target: WorkspaceTarget;
+    /** Whether a sibling can be opened where this switch lives; a closed sibling stays listed but disabled. */
+    canOpen?: (page: PageModel) => boolean;
+    closedReason?: string;
+    onSwitch: (page: PageModel) => void;
+}
+/**
+ * One select over the declared states of the current screen. It renders
+ * nothing while the screen has no sibling state to flip to, so a switch never
+ * announces a choice that does not exist.
+ */
+export declare const ScreenStateSwitch: import("react").FunctionComponent<ScreenStateSwitchProps>;

package/dist-lib/types/workspace/capture/captureMedia.d.ts

@@ -0,0 +1,41 @@
+import { type DocumentAsset } from '../../document/assets.js';
+import { type ScreenImportMedia } from './contracts.js';
+export interface SettleScreenOptions {
+    /** The import controller's stability wait, when the host connected one. */
+    waitForStableDocument?(document: Document): Promise<boolean>;
+}
+export interface SettleScreenReport {
+    finishedAnimations: number;
+    cancelledAnimations: number;
+    stable: boolean | null;
+}
+/** Entrance transitions and image decoding must finish before boxes and opacities are read. */
+export declare function settleScreen(document: Document, options?: SettleScreenOptions): Promise<SettleScreenReport>;
+export interface CollectScreenMediaOptions {
+    signal?: AbortSignal;
+    /** Total time for fetching and rasterizing; media beyond the budget stay placeholders. Default 8000. */
+    budgetMs?: number;
+    /** Fetches encoded bytes for a same-origin or CORS-readable URL; null means unreadable. */
+    fetchBytes?(url: string, signal?: AbortSignal): Promise<Uint8Array | null>;
+    /** Draws an element to PNG bytes at the given CSS size; null means the canvas was tainted or unsupported. */
+    rasterize?(element: Element, size: {
+        width: number;
+        height: number;
+    }): Promise<Uint8Array | null>;
+}
+export interface CollectedScreenMedia {
+    media: Record<string, ScreenImportMedia>;
+    assets: DocumentAsset[];
+    diagnostics: string[];
+    stamped: number;
+}
+/**
+ * Serializes an inline SVG the way the editable importer can read it: computed fill and stroke replace
+ * class-driven styling and `currentColor`, rounded rectangles become cubic paths, and non-presentational attributes drop out.
+ */
+export declare function editableSvgMarkup(element: Element): string;
+/**
+ * Stamps every media element and element with a CSS background image, then gathers the bytes behind them.
+ * The stamps survive the DOM importer as attributes, so the converter can match layers to this media map.
+ */
+export declare function collectScreenMedia(document: Document, options?: CollectScreenMediaOptions): Promise<CollectedScreenMedia>;

package/dist-lib/types/workspace/capture/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { DocumentAsset, ImageScaleMode } from '../../document/assets.js';
 import type { DesignDocument, DocumentDiagnostic } from '../../document/contracts.js';
 import type { ImportedGeometryEntry } from '../../editor/domImport.js';
 import type { NodeJSON, PageModel } from '../../editor/store.js';
@@ -15,7 +16,26 @@ export interface ScreenImportSource {
     geometry: readonly ImportedGeometryEntry[];
     truncated?: boolean;
     importDiagnostics?: readonly string[];
+    /** Media observed on the screen, keyed by the stamp the loader wrote on each element before import. */
+    media?: Readonly<Record<string, ScreenImportMedia>>;
+    /** Image assets the media entries reference; only referenced assets enter the document. */
+    assets?: readonly DocumentAsset[];
 }
+/** The attribute the loader stamps on media elements so their layers can be matched after import. */
+export declare const MEDIA_STAMP_ATTRIBUTE = "data-pygmalion-media";
+export type ScreenImportMedia = {
+    kind: 'svg';
+    markup: string;
+    rasterAssetId?: string;
+} | {
+    kind: 'image';
+    assetId: string;
+    scaleMode: ImageScaleMode;
+} | {
+    kind: 'background';
+    assetId: string;
+    scaleMode: ImageScaleMode;
+};
 export interface ScreenImportResult {
     document: DesignDocument;
     diagnostics: DocumentDiagnostic[];
@@ -43,6 +63,8 @@ export interface CapturedScreenDocumentOptions {
     };
     /** Milliseconds to wait for the screen to load and prepare before giving up. Default 45000. */
     timeoutMs?: number;
+    /** Milliseconds spent collecting images and drawings before the import continues without the rest. Default 8000. */
+    mediaBudgetMs?: number;
     /** Where the offscreen frame mounts; default is the document body of the page running the editor. */
     container?: HTMLElement;
 }

package/dist-lib/types/workspace/configuration.d.ts

@@ -40,7 +40,7 @@ export interface WorkspaceConfiguration extends WorkspaceTargetConfiguration {
     /** Undefined explicitly marks an unsupported screen or source revision. */
     resolveTarget?(target: WorkspaceTarget): WorkspaceTargetConfiguration | undefined;
     /** Open any routed screen the host does not resolve as an imported design document; edits stay drafts until the host connects a source mapping. */
-    capturedScreens?: true | CapturedScreenDocumentOptions;
+    capturedScreens?: boolean | CapturedScreenDocumentOptions;
 }
 export interface WorkspaceTargetResolverOptions {
     /** The host decides whether this screen and revision have usable capabilities. */
@@ -50,6 +50,8 @@ export interface WorkspaceTargetResolverOptions {
 }
 /** Retain capability identities per screen and revision; unsupported targets remain retryable. */
 export declare function createWorkspaceTargetResolver({ resolve, maxEntries }: WorkspaceTargetResolverOptions): (target: WorkspaceTarget) => WorkspaceTargetConfiguration | undefined;
+/** Whether Edit can open this target: its resolved capabilities include a document loader. Never loads anything. */
+export declare function canEditWorkspaceTarget(configuration: WorkspaceConfiguration, target: WorkspaceTarget | null | undefined): boolean;
 /** An explicit target resolver never inherits capabilities from the root configuration. */
 export declare function resolveWorkspaceTarget(configuration: WorkspaceConfiguration, target: WorkspaceTarget): WorkspaceTargetConfiguration | undefined;
 /** Compares captured capability identities without invoking any host callbacks. */

package/dist-lib/types/workspace/screenStates.d.ts

@@ -0,0 +1,32 @@
+import type { PageModel } from '../editor/store.js';
+/**
+ * Sibling states of one screen are a host declaration: pages that share a
+ * scenario belong together (see `editor/screenStateGroups.ts`). The core never
+ * infers membership from names, routes, or canvas proximity, so a screen
+ * without a scenario simply has no siblings to flip to.
+ */
+export interface ScreenStateMember {
+    page: PageModel;
+    screenId: string;
+    /** The declared state label; an undeclared state is the default one. */
+    label: string;
+    /** Host-declared kind of the state branch (overlay, badge, layout, …), presentation only. */
+    kind?: string;
+    current: boolean;
+}
+export interface ScreenStateGroup {
+    /** The shared scenario declaration. */
+    key: string;
+    /** The default member's name, or the first declared member's. */
+    name: string;
+    members: readonly ScreenStateMember[];
+}
+export declare const isScreenPage: (page: PageModel) => boolean;
+export declare const screenStateLabel: (page: PageModel) => string;
+/**
+ * The declared states of the screen `screenId` belongs to, default state first
+ * and then in declaration order. Hidden siblings (other runtimes or conditions)
+ * are left out; the current state always stays. Returns null when the screen
+ * is unknown or declares no scenario.
+ */
+export declare function screenStateGroup(pages: readonly PageModel[], screenId: string, isVisible?: (page: PageModel) => boolean): ScreenStateGroup | null;

package/package.json

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