@cratis/scene.blueprint.default 4.33.0 → 4.35.0

package/dist/cjs/preview-host/useSizeClass.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var react = require('react');
+var scene_engine = require('@cratis/scene.engine');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Tracks the browser window's {@link SizeClass}, recomputing whenever it resizes across a boundary the
+ * shared engine cares about. This is what lets a modeled `when width compact` override actually take
+ * effect on a narrow window instead of the arrangement engine's size-aware logic never being asked.
+ */ function useSizeClass() {
+    const [sizeClass, setSizeClass] = react.useState(()=>scene_engine.computeSizeClass(globalThis.innerWidth, globalThis.innerHeight));
+    react.useEffect(()=>{
+        const onResize = ()=>setSizeClass(scene_engine.computeSizeClass(globalThis.innerWidth, globalThis.innerHeight));
+        globalThis.addEventListener('resize', onResize);
+        return ()=>globalThis.removeEventListener('resize', onResize);
+    }, []);
+    return sizeClass;
+}
+
+exports.useSizeClass = useSizeClass;
+//# sourceMappingURL=useSizeClass.js.map

package/dist/cjs/preview-host/useSizeClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSizeClass.js","sources":["../../../preview-host/useSizeClass.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { useEffect, useState } from 'react';\nimport type { SizeClass } from '@cratis/scene.model';\nimport { computeSizeClass } from '@cratis/scene.engine';\n\n/**\n * Tracks the browser window's {@link SizeClass}, recomputing whenever it resizes across a boundary the\n * shared engine cares about. This is what lets a modeled `when width compact` override actually take\n * effect on a narrow window instead of the arrangement engine's size-aware logic never being asked.\n */\nexport function useSizeClass(): SizeClass {\n    const [sizeClass, setSizeClass] = useState<SizeClass>(() => computeSizeClass(globalThis.innerWidth, globalThis.innerHeight));\n\n    useEffect(() => {\n        const onResize = () => setSizeClass(computeSizeClass(globalThis.innerWidth, globalThis.innerHeight));\n        globalThis.addEventListener('resize', onResize);\n        return () => globalThis.removeEventListener('resize', onResize);\n    }, []);\n\n    return sizeClass;\n}\n"],"names":["useSizeClass","sizeClass","setSizeClass","useState","computeSizeClass","globalThis","innerWidth","innerHeight","useEffect","onResize","addEventListener","removeEventListener"],"mappings":";;;;;AAAA;AACA;AAMA;;;;AAIC,IACM,SAASA,YAAAA,GAAAA;IACZ,MAAM,CAACC,SAAAA,EAAWC,YAAAA,CAAa,GAAGC,cAAAA,CAAoB,IAAMC,6BAAAA,CAAiBC,UAAAA,CAAWC,UAAU,EAAED,UAAAA,CAAWE,WAAW,CAAA,CAAA;IAE1HC,eAAAA,CAAU,IAAA;QACN,MAAMC,QAAAA,GAAW,IAAMP,YAAAA,CAAaE,6BAAAA,CAAiBC,WAAWC,UAAU,EAAED,WAAWE,WAAW,CAAA,CAAA;QAClGF,UAAAA,CAAWK,gBAAgB,CAAC,QAAA,EAAUD,QAAAA,CAAAA;AACtC,QAAA,OAAO,IAAMJ,UAAAA,CAAWM,mBAAmB,CAAC,QAAA,EAAUF,QAAAA,CAAAA;AAC1D,IAAA,CAAA,EAAG,EAAE,CAAA;IAEL,OAAOR,SAAAA;AACX;;"}

package/dist/esm/index.d.ts

@@ -9,4 +9,5 @@ export * from './themes';
 export * from './defaultBlueprintComponents';
 export * from './defaultBlueprint';
 export * from './templateProvenance';
+export * from './preview-host';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}

package/dist/esm/index.js

@@ -84,4 +84,21 @@ export { LayoutThemeProvider } from './themes/LayoutThemeProvider.js';
 export { defaultBlueprintComponents } from './defaultBlueprintComponents.js';
 export { defaultBlueprint, defaultBlueprintManifest } from './defaultBlueprint.js';
 export { defaultBlueprintTemplateProvenance, sakaiCompositionProvenance } from './templateProvenance.js';
+export { isSliceTarget } from './preview-host/PreviewTarget.js';
+export { PreviewProblemCode, PreviewProblemSeverity, hasBlockingProblem } from './preview-host/PreviewProblem.js';
+export { completeDocument } from './preview-host/ApplicationDocument.js';
+export { blueprintPackageCatalog, previewProfile, requiredPackages } from './preview-host/previewProfile.js';
+export { defaultApplicationChrome } from './preview-host/defaultApplicationChrome.js';
+export { FlowArrangementView } from './preview-host/FlowArrangementView.js';
+export { useSizeClass } from './preview-host/useSizeClass.js';
+export { PreviewTemplate, previewComponents, previewTemplateComponent } from './preview-host/PreviewTemplate.js';
+export { collectDestinations, composeApplicationScreen, composeDialog, composeOutletScreen, findLayout, screenContent, templateChainOf, templatePoolFor, templatesOf } from './preview-host/composeApplication.js';
+export { resolvePreviewPlan } from './preview-host/resolvePreviewPlan.js';
+export { diagnosePreview } from './preview-host/diagnosePreview.js';
+export { collectQueryNames, createPreviewSampleData } from './preview-host/previewSampleData.js';
+export { findSliceFragment } from './preview-host/PreviewSliceFragment.js';
+export { PreviewToast } from './preview-host/PreviewToast.js';
+export { PreviewProblemsView } from './preview-host/PreviewProblemsView.js';
+export { ApplicationHost } from './preview-host/ApplicationHost.js';
+export { ScenePreviewHost } from './preview-host/ScenePreviewHost.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/preview-host/ApplicationDocument.d.ts

@@ -0,0 +1,7 @@
+import type { SceneDocument, Theme, UiProfile } from '@cratis/scene.model';
+export type ApplicationDocument = Pick<SceneDocument, 'layouts' | 'screenTemplates' | 'screens'> & Partial<Pick<SceneDocument, 'dialogTemplates' | 'exposures' | 'instanceContributions'>> & {
+    uiProfiles?: UiProfile[];
+    themes?: Theme[];
+};
+export declare function completeDocument(application: ApplicationDocument): SceneDocument;
+//# sourceMappingURL=ApplicationDocument.d.ts.map

package/dist/esm/preview-host/ApplicationDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplicationDocument.d.ts","sourceRoot":"","sources":["../../../preview-host/ApplicationDocument.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAO3E,MAAM,MAAM,mBAAmB,GACzB,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,iBAAiB,GAAG,SAAS,CAAC,GAC9D,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,iBAAiB,GAAG,WAAW,GAAG,uBAAuB,CAAC,CAAC,GACvF;IAEE,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IAEzB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;CACpB,CAAC;AAGN,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,mBAAmB,GAAG,aAAa,CAShF"}

package/dist/esm/preview-host/ApplicationDocument.js

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The document with everything a template chain needs filled in. */ function completeDocument(application) {
+    return {
+        layouts: application.layouts,
+        screenTemplates: application.screenTemplates,
+        dialogTemplates: application.dialogTemplates ?? [],
+        screens: application.screens,
+        exposures: application.exposures ?? [],
+        instanceContributions: application.instanceContributions ?? []
+    };
+}
+
+export { completeDocument };
+//# sourceMappingURL=ApplicationDocument.js.map

package/dist/esm/preview-host/ApplicationDocument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplicationDocument.js","sources":["../../../preview-host/ApplicationDocument.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport type { SceneDocument, Theme, UiProfile } from '@cratis/scene.model';\n\n/**\n * What an application is made of: the document a designer edits - layouts, templates, screens, and what a template exposes and\n * each instance contributes - and the profile and theme the application renders with. Stage assembles it from a Screenplay\n * model, Studio from the model in memory (unsaved edits included); the composition and the hosts take nothing else.\n */\nexport type ApplicationDocument =\n    & Pick<SceneDocument, 'layouts' | 'screenTemplates' | 'screens'>\n    & Partial<Pick<SceneDocument, 'dialogTemplates' | 'exposures' | 'instanceContributions'>>\n    & {\n        /** The profiles the application declares; the first for the web is the one rendered with. */\n        uiProfiles?: UiProfile[];\n\n        themes?: Theme[];\n    };\n\n/** The document with everything a template chain needs filled in. */\nexport function completeDocument(application: ApplicationDocument): SceneDocument {\n    return {\n        layouts: application.layouts,\n        screenTemplates: application.screenTemplates,\n        dialogTemplates: application.dialogTemplates ?? [],\n        screens: application.screens,\n        exposures: application.exposures ?? [],\n        instanceContributions: application.instanceContributions ?? [],\n    };\n}\n"],"names":["completeDocument","application","layouts","screenTemplates","dialogTemplates","screens","exposures","instanceContributions"],"mappings":"AAAA;AACA;AAmBA,sEACO,SAASA,gBAAAA,CAAiBC,WAAgC,EAAA;IAC7D,OAAO;AACHC,QAAAA,OAAAA,EAASD,YAAYC,OAAO;AAC5BC,QAAAA,eAAAA,EAAiBF,YAAYE,eAAe;QAC5CC,eAAAA,EAAiBH,WAAAA,CAAYG,eAAe,IAAI,EAAE;AAClDC,QAAAA,OAAAA,EAASJ,YAAYI,OAAO;QAC5BC,SAAAA,EAAWL,WAAAA,CAAYK,SAAS,IAAI,EAAE;QACtCC,qBAAAA,EAAuBN,WAAAA,CAAYM,qBAAqB,IAAI;AAChE,KAAA;AACJ;;"}

package/dist/esm/preview-host/ApplicationHost.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { DialogTemplate, SceneElement, type EffectiveConfiguration } from '@cratis/scene.model';
+import { BindingResolver } from '@cratis/scene.engine';
+import { ComponentRegistry, SceneHistory, SceneNavigationContextValue, SceneNavigationModel } from '@cratis/scene.react';
+import { ApplicationDocument } from './ApplicationDocument';
+import { CompositionOptions } from './composeApplication';
+export interface ApplicationHostProps {
+    application: ApplicationDocument;
+    composition?: CompositionOptions;
+    navigationModel: SceneNavigationModel;
+    registry: ComponentRegistry;
+    initialScreen: string;
+    history?: SceneHistory;
+    resolveBinding?: BindingResolver;
+    queryResults?: Record<string, unknown>;
+    renderScreen?(element: SceneElement, configuration: EffectiveConfiguration | undefined, navigation: SceneNavigationContextValue): ReactNode;
+    renderDialog?(navigation: SceneNavigationContextValue): ReactNode;
+    renderDialogTemplate?(template: DialogTemplate, content: SceneElement, navigation: SceneNavigationContextValue): ReactNode;
+    scope?(navigation: SceneNavigationContextValue, children: ReactNode): ReactNode;
+    layoutConfigStorage?: Storage | null;
+    children?: ReactNode;
+}
+export declare function ApplicationHost({ application, composition, navigationModel, registry: hostRegistry, initialScreen, history, resolveBinding, queryResults, renderScreen, renderDialog, renderDialogTemplate, scope, layoutConfigStorage, children }: ApplicationHostProps): import("react").JSX.Element;
+//# sourceMappingURL=ApplicationHost.d.ts.map

package/dist/esm/preview-host/ApplicationHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplicationHost.d.ts","sourceRoot":"","sources":["../../../preview-host/ApplicationHost.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAqB,MAAM,OAAO,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAChG,OAAO,EAAE,eAAe,EAAgB,MAAM,sBAAsB,CAAC;AACrE,OAAO,EACH,iBAAiB,EAAoB,YAAY,EAAE,2BAA2B,EAAE,oBAAoB,EAGvG,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,EAAE,kBAAkB,EAAqF,MAAM,sBAAsB,CAAC;AAE7I,MAAM,WAAW,oBAAoB;IAEjC,WAAW,EAAE,mBAAmB,CAAC;IAGjC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IAGjC,eAAe,EAAE,oBAAoB,CAAC;IAEtC,QAAQ,EAAE,iBAAiB,CAAC;IAG5B,aAAa,EAAE,MAAM,CAAC;IAGtB,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,cAAc,CAAC,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAQvC,YAAY,CAAC,CAAC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,GAAG,SAAS,EAAE,UAAU,EAAE,2BAA2B,GAAG,SAAS,CAAC;IAM5I,YAAY,CAAC,CAAC,UAAU,EAAE,2BAA2B,GAAG,SAAS,CAAC;IASlE,oBAAoB,CAAC,CAAC,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,2BAA2B,GAAG,SAAS,CAAC;IAS3H,KAAK,CAAC,CAAC,UAAU,EAAE,2BAA2B,EAAE,QAAQ,EAAE,SAAS,GAAG,SAAS,CAAC;IAMhF,mBAAmB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAGrC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACxB;AASD,wBAAgB,eAAe,CAAC,EAAE,WAAW,EAAE,WAAgB,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,KAAK,EAAE,mBAA0B,EAAE,QAAQ,EAAE,EAAE,oBAAoB,+BA8DpR"}

package/dist/esm/preview-host/ApplicationHost.js

@@ -0,0 +1,132 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { useState, useMemo } from 'react';
+import { createMemorySceneHistory, collectOutletOwners, navigationDestinations, sceneRoutesFrom, useSceneHistoryNavigation, sliceDialogParameters, SceneElementView, SliceDialogView, SceneNavigationProvider, SceneOutletContext, SceneNavigationModelProvider } from '@cratis/scene.react';
+import { LayoutConfigProvider } from '../configuration/LayoutConfigProvider.js';
+import { previewComponents } from './PreviewTemplate.js';
+import { composeOutletScreen, collectDestinations, composeApplicationScreen, composeDialog } from './composeApplication.js';
+
+/**
+ * The application as both Stage and the preview host run it: the shell composed for the screen on the page
+ * (`composeApplicationScreen`), nested outlets holding the screens placed in them, the navigation model in scope for the shell's
+ * topbar and sidebar regions, every destination the document and the navigation lead to routed, and the dialog a toolbar slice
+ * button or a dialog destination opened shown over it - one place for all of it (spec PRV9), so a behaviour that differs between
+ * the two hosts is a bug in the host, not a second implementation.
+ */ function ApplicationHost({ application, composition = {}, navigationModel, registry: hostRegistry, initialScreen, history, resolveBinding, queryResults, renderScreen, renderDialog, renderDialogTemplate, scope, layoutConfigStorage = null, children }) {
+    const [memoryHistory] = useState(()=>createMemorySceneHistory());
+    const registry = useMemo(()=>({
+            ...previewComponents,
+            ...hostRegistry
+        }), [
+        hostRegistry
+    ]);
+    const hostHistory = history ?? memoryHistory;
+    const screens = application.screens;
+    const outletScreens = useMemo(()=>Object.fromEntries(screens.map((candidate)=>[
+                candidate.name,
+                composeOutletScreen(application, candidate, composition)
+            ])), [
+        application,
+        composition,
+        screens
+    ]);
+    const owners = useMemo(()=>collectOutletOwners(outletScreens), [
+        outletScreens
+    ]);
+    const destinations = useMemo(()=>[
+            ...collectDestinations(application),
+            ...navigationDestinations(navigationModel.structure, navigationModel.navigation, navigationModel.screenFor)
+        ], [
+        application,
+        navigationModel
+    ]);
+    const routes = useMemo(()=>sceneRoutesFrom(screens.map((candidate)=>candidate.name), destinations), [
+        destinations,
+        screens
+    ]);
+    const bindingScope = useMemo(()=>({
+            queryResults
+        }), [
+        queryResults
+    ]);
+    const navigation = useSceneHistoryNavigation(hostHistory, routes, initialScreen, bindingScope, owners, destinations);
+    const screen = screens.find((candidate)=>candidate.name === navigation.primaryScreen) ?? screens.find((candidate)=>candidate.name === initialScreen) ?? screens[0];
+    const composed = useMemo(()=>screen ? composeApplicationScreen(application, screen, composition) : undefined, [
+        application,
+        composition,
+        screen
+    ]);
+    const outletContext = useMemo(()=>({
+            screens: outletScreens,
+            registry
+        }), [
+        outletScreens,
+        registry
+    ]);
+    const dialogTemplate = navigation.currentDialog ? application.dialogTemplates?.find((candidate)=>candidate.name === navigation.currentDialog) : undefined;
+    const sliceDialog = !dialogTemplate && navigation.currentDialog && sliceDialogParameters(navigation.currentDialogParameters) !== undefined;
+    const dialogName = sliceDialogParameters(navigation.currentDialogParameters)?.title ?? navigation.currentDialog;
+    const dialogContent = dialogTemplate ? composeDialog(application, dialogTemplate, composition) : undefined;
+    const body = /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                "data-scene-outlet": "primary",
+                "data-scene-url": navigation.currentUrl,
+                "data-scene-screen": navigation.primaryScreen,
+                children: composed && /*#__PURE__*/ jsx(Drawn, {
+                    children: renderScreen ? ()=>renderScreen(composed.element, composed.configuration, navigation) : ()=>/*#__PURE__*/ jsx(SceneElementView, {
+                            element: composed.element,
+                            registry: registry,
+                            resolveBinding: resolveBinding,
+                            queryResults: queryResults,
+                            configuration: composed.configuration
+                        })
+                })
+            }),
+            dialogTemplate && dialogContent && (renderDialogTemplate ? /*#__PURE__*/ jsx(Drawn, {
+                children: ()=>renderDialogTemplate(dialogTemplate, dialogContent, navigation)
+            }) : /*#__PURE__*/ jsx("div", {
+                role: "dialog",
+                "aria-modal": "true",
+                "aria-label": dialogName,
+                "data-scene-dialog": navigation.currentDialog,
+                children: /*#__PURE__*/ jsx(SceneElementView, {
+                    element: dialogContent,
+                    registry: registry,
+                    resolveBinding: resolveBinding,
+                    queryResults: queryResults
+                })
+            })),
+            sliceDialog && /*#__PURE__*/ jsx("div", {
+                role: "dialog",
+                "aria-modal": "true",
+                "aria-label": dialogName,
+                "data-scene-dialog": navigation.currentDialog,
+                children: renderDialog?.(navigation) ?? /*#__PURE__*/ jsx(SliceDialogView, {})
+            })
+        ]
+    });
+    return /*#__PURE__*/ jsx(SceneNavigationProvider, {
+        value: navigation,
+        children: /*#__PURE__*/ jsx(SceneOutletContext.Provider, {
+            value: outletContext,
+            children: /*#__PURE__*/ jsx(SceneNavigationModelProvider, {
+                model: navigationModel,
+                children: /*#__PURE__*/ jsxs(LayoutConfigProvider, {
+                    storage: layoutConfigStorage,
+                    children: [
+                        scope ? scope(navigation, body) : body,
+                        children
+                    ]
+                })
+            })
+        })
+    });
+}
+/** Calls what a host draws as part of this component, so a hook it uses runs under the providers the host put in scope. */ function Drawn({ children }) {
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: children()
+    });
+}
+
+export { ApplicationHost };
+//# sourceMappingURL=ApplicationHost.js.map

package/dist/esm/preview-host/ApplicationHost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplicationHost.js","sources":["../../../preview-host/ApplicationHost.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ReactNode, useMemo, useState } from 'react';\nimport { DialogTemplate, SceneElement, type EffectiveConfiguration } from '@cratis/scene.model';\nimport { BindingResolver, BindingScope } from '@cratis/scene.engine';\nimport {\n    ComponentRegistry, SceneElementView, SceneHistory, SceneNavigationContextValue, SceneNavigationModel, SceneNavigationModelProvider,\n    SceneNavigationProvider, SceneOutletContext, SliceDialogView, collectOutletOwners, createMemorySceneHistory, navigationDestinations,\n    sceneRoutesFrom, sliceDialogParameters, useSceneHistoryNavigation,\n} from '@cratis/scene.react';\nimport { LayoutConfigProvider } from '../configuration';\nimport { ApplicationDocument } from './ApplicationDocument';\nimport { previewComponents } from './PreviewTemplate';\nimport { CompositionOptions, collectDestinations, composeApplicationScreen, composeDialog, composeOutletScreen } from './composeApplication';\n\nexport interface ApplicationHostProps {\n    /** The document the application is composed from. */\n    application: ApplicationDocument;\n\n    /** What the host decides about composition; Stage and the preview host differ only here. */\n    composition?: CompositionOptions;\n\n    /** The structure and navigation the shell's regions show and the items' destinations resolve against. */\n    navigationModel: SceneNavigationModel;\n\n    registry: ComponentRegistry;\n\n    /** The screen shown first. */\n    initialScreen: string;\n\n    /** Where entries are recorded: the address bar for Stage, an in-memory history for a preview, which never touches the host's URL (PRV4). */\n    history?: SceneHistory;\n\n    /** What the screens' bindings resolve against. */\n    resolveBinding?: BindingResolver;\n    queryResults?: Record<string, unknown>;\n\n    /**\n     * Draws the composed screen. The default renders it with `SceneElementView`; Stage wraps it with its data and command scope.\n     * @param element The composed screen.\n     * @param configuration What the screen's templates were configured with.\n     * @param navigation Where the user is.\n     */\n    renderScreen?(element: SceneElement, configuration: EffectiveConfiguration | undefined, navigation: SceneNavigationContextValue): ReactNode;\n\n    /**\n     * Draws what the open dialog shows when the document has no dialog template of that name - a toolbar slice button's task\n     * dialog by default.\n     */\n    renderDialog?(navigation: SceneNavigationContextValue): ReactNode;\n\n    /**\n     * Draws a dialog the document declares, in place of the host's plain one - a host that wants its own backdrop, a close button\n     * and keyboard handling around the template's content. Called inside {@link scope}.\n     * @param template The dialog template that is open.\n     * @param content The template's composed content.\n     * @param navigation Where the user is.\n     */\n    renderDialogTemplate?(template: DialogTemplate, content: SceneElement, navigation: SceneNavigationContextValue): ReactNode;\n\n    /**\n     * What a host provides around everything that renders - the screen on the page and the dialog over it: its data, its command\n     * dispatcher, its chrome state. Inside the navigation providers, so it can read where the user is. Stage puts its data and\n     * interaction scope here, so the screen, a dialog template and a slice dialog all share them.\n     * @param navigation Where the user is.\n     * @param children The screen and the dialog.\n     */\n    scope?(navigation: SceneNavigationContextValue, children: ReactNode): ReactNode;\n\n    /**\n     * Where the shell keeps its layout configuration - the sidebar's state, the chosen theme. A preview keeps none (null, the default);\n     * a running application passes its storage so what a user chose is still chosen on the next visit.\n     */\n    layoutConfigStorage?: Storage | null;\n\n    /** Rendered inside the host's providers, after the application. */\n    children?: ReactNode;\n}\n\n/**\n * The application as both Stage and the preview host run it: the shell composed for the screen on the page\n * (`composeApplicationScreen`), nested outlets holding the screens placed in them, the navigation model in scope for the shell's\n * topbar and sidebar regions, every destination the document and the navigation lead to routed, and the dialog a toolbar slice\n * button or a dialog destination opened shown over it - one place for all of it (spec PRV9), so a behaviour that differs between\n * the two hosts is a bug in the host, not a second implementation.\n */\nexport function ApplicationHost({ application, composition = {}, navigationModel, registry: hostRegistry, initialScreen, history, resolveBinding, queryResults, renderScreen, renderDialog, renderDialogTemplate, scope, layoutConfigStorage = null, children }: ApplicationHostProps) {\n    const [memoryHistory] = useState(() => createMemorySceneHistory());\n    const registry = useMemo(() => ({ ...previewComponents, ...hostRegistry }), [hostRegistry]);\n    const hostHistory = history ?? memoryHistory;\n    const screens = application.screens;\n\n    const outletScreens = useMemo(\n        () => Object.fromEntries(screens.map(candidate => [candidate.name, composeOutletScreen(application, candidate, composition)])),\n        [application, composition, screens]);\n    const owners = useMemo(() => collectOutletOwners(outletScreens), [outletScreens]);\n    const destinations = useMemo(\n        () => [...collectDestinations(application), ...navigationDestinations(navigationModel.structure, navigationModel.navigation, navigationModel.screenFor)],\n        [application, navigationModel]);\n    const routes = useMemo(() => sceneRoutesFrom(screens.map(candidate => candidate.name), destinations), [destinations, screens]);\n    const bindingScope = useMemo<BindingScope>(() => ({ queryResults }), [queryResults]);\n    const navigation = useSceneHistoryNavigation(hostHistory, routes, initialScreen, bindingScope, owners, destinations);\n\n    const screen = screens.find(candidate => candidate.name === navigation.primaryScreen) ?? screens.find(candidate => candidate.name === initialScreen) ?? screens[0];\n    const composed = useMemo(() => screen ? composeApplicationScreen(application, screen, composition) : undefined, [application, composition, screen]);\n    const outletContext = useMemo(() => ({ screens: outletScreens, registry }), [outletScreens, registry]);\n\n    const dialogTemplate = navigation.currentDialog ? application.dialogTemplates?.find(candidate => candidate.name === navigation.currentDialog) : undefined;\n    const sliceDialog = !dialogTemplate && navigation.currentDialog && sliceDialogParameters(navigation.currentDialogParameters) !== undefined;\n    const dialogName = sliceDialogParameters(navigation.currentDialogParameters)?.title ?? navigation.currentDialog;\n\n    const dialogContent = dialogTemplate ? composeDialog(application, dialogTemplate, composition) : undefined;\n\n    const body = (\n        <>\n            <div data-scene-outlet='primary' data-scene-url={navigation.currentUrl} data-scene-screen={navigation.primaryScreen}>\n                {composed && <Drawn>{renderScreen\n                    ? () => renderScreen(composed.element, composed.configuration, navigation)\n                    : () => <SceneElementView element={composed.element} registry={registry} resolveBinding={resolveBinding} queryResults={queryResults} configuration={composed.configuration} />}</Drawn>}\n            </div>\n            {dialogTemplate && dialogContent && (renderDialogTemplate\n                ? <Drawn>{() => renderDialogTemplate(dialogTemplate, dialogContent, navigation)}</Drawn>\n                : (\n                    <div role='dialog' aria-modal='true' aria-label={dialogName} data-scene-dialog={navigation.currentDialog}>\n                        <SceneElementView element={dialogContent} registry={registry} resolveBinding={resolveBinding} queryResults={queryResults} />\n                    </div>\n                ))}\n            {sliceDialog && (\n                <div role='dialog' aria-modal='true' aria-label={dialogName} data-scene-dialog={navigation.currentDialog}>\n                    {renderDialog?.(navigation) ?? <SliceDialogView />}\n                </div>\n            )}\n        </>\n    );\n\n    return (\n        <SceneNavigationProvider value={navigation}>\n            <SceneOutletContext.Provider value={outletContext}>\n                <SceneNavigationModelProvider model={navigationModel}>\n                    {/* The shell reads its layout configuration from a provider; nothing is saved unless the host gives it somewhere to. */}\n                    <LayoutConfigProvider storage={layoutConfigStorage}>\n                        {scope ? scope(navigation, body) : body}\n                        {children}\n                    </LayoutConfigProvider>\n                </SceneNavigationModelProvider>\n            </SceneOutletContext.Provider>\n        </SceneNavigationProvider>\n    );\n}\n\n/** Calls what a host draws as part of this component, so a hook it uses runs under the providers the host put in scope. */\nfunction Drawn({ children }: { children(): ReactNode }) {\n    return <>{children()}</>;\n}\n"],"names":["ApplicationHost","application","composition","navigationModel","registry","hostRegistry","initialScreen","history","resolveBinding","queryResults","renderScreen","renderDialog","renderDialogTemplate","scope","layoutConfigStorage","children","memoryHistory","useState","createMemorySceneHistory","useMemo","previewComponents","hostHistory","screens","outletScreens","Object","fromEntries","map","candidate","name","composeOutletScreen","owners","collectOutletOwners","destinations","collectDestinations","navigationDestinations","structure","navigation","screenFor","routes","sceneRoutesFrom","bindingScope","useSceneHistoryNavigation","screen","find","primaryScreen","composed","composeApplicationScreen","undefined","outletContext","dialogTemplate","currentDialog","dialogTemplates","sliceDialog","sliceDialogParameters","currentDialogParameters","dialogName","title","dialogContent","composeDialog","body","_jsxs","_Fragment","_jsx","div","data-scene-outlet","data-scene-url","currentUrl","data-scene-screen","Drawn","element","configuration","SceneElementView","role","aria-modal","aria-label","data-scene-dialog","SliceDialogView","SceneNavigationProvider","value","SceneOutletContext","Provider","SceneNavigationModelProvider","model","LayoutConfigProvider","storage"],"mappings":";;;;;;;AAgFA;;;;;;AAMC,IACM,SAASA,eAAAA,CAAgB,EAAEC,WAAW,EAAEC,WAAAA,GAAc,EAAE,EAAEC,eAAe,EAAEC,QAAAA,EAAUC,YAAY,EAAEC,aAAa,EAAEC,OAAO,EAAEC,cAAc,EAAEC,YAAY,EAAEC,YAAY,EAAEC,YAAY,EAAEC,oBAAoB,EAAEC,KAAK,EAAEC,mBAAAA,GAAsB,IAAI,EAAEC,QAAQ,EAAwB,EAAA;AACjR,IAAA,MAAM,CAACC,aAAAA,CAAc,GAAGC,QAAAA,CAAS,IAAMC,wBAAAA,EAAAA,CAAAA;IACvC,MAAMd,QAAAA,GAAWe,OAAAA,CAAQ,KAAO;AAAE,YAAA,GAAGC,iBAAiB;AAAE,YAAA,GAAGf;AAAa,SAAA,CAAA,EAAI;AAACA,QAAAA;AAAa,KAAA,CAAA;AAC1F,IAAA,MAAMgB,cAAcd,OAAAA,IAAWS,aAAAA;IAC/B,MAAMM,OAAAA,GAAUrB,YAAYqB,OAAO;IAEnC,MAAMC,aAAAA,GAAgBJ,OAAAA,CAClB,IAAMK,MAAAA,CAAOC,WAAW,CAACH,OAAAA,CAAQI,GAAG,CAACC,CAAAA,SAAAA,GAAa;AAACA,gBAAAA,SAAAA,CAAUC,IAAI;AAAEC,gBAAAA,mBAAAA,CAAoB5B,aAAa0B,SAAAA,EAAWzB,WAAAA;aAAa,CAAA,CAAA,EAC5H;AAACD,QAAAA,WAAAA;AAAaC,QAAAA,WAAAA;AAAaoB,QAAAA;AAAQ,KAAA,CAAA;AACvC,IAAA,MAAMQ,MAAAA,GAASX,OAAAA,CAAQ,IAAMY,mBAAAA,CAAoBR,aAAAA,CAAAA,EAAgB;AAACA,QAAAA;AAAc,KAAA,CAAA;IAChF,MAAMS,YAAAA,GAAeb,QACjB,IAAM;eAAIc,mBAAAA,CAAoBhC,WAAAA,CAAAA;AAAiBiC,YAAAA,GAAAA,sBAAAA,CAAuB/B,gBAAgBgC,SAAS,EAAEhC,gBAAgBiC,UAAU,EAAEjC,gBAAgBkC,SAAS;SAAE,EACxJ;AAACpC,QAAAA,WAAAA;AAAaE,QAAAA;AAAgB,KAAA,CAAA;AAClC,IAAA,MAAMmC,MAAAA,GAASnB,OAAAA,CAAQ,IAAMoB,eAAAA,CAAgBjB,OAAAA,CAAQI,GAAG,CAACC,CAAAA,SAAAA,GAAaA,SAAAA,CAAUC,IAAI,CAAA,EAAGI,YAAAA,CAAAA,EAAe;AAACA,QAAAA,YAAAA;AAAcV,QAAAA;AAAQ,KAAA,CAAA;IAC7H,MAAMkB,YAAAA,GAAerB,OAAAA,CAAsB,KAAO;AAAEV,YAAAA;AAAa,SAAA,CAAA,EAAI;AAACA,QAAAA;AAAa,KAAA,CAAA;AACnF,IAAA,MAAM2B,aAAaK,yBAAAA,CAA0BpB,WAAAA,EAAaiB,MAAAA,EAAQhC,aAAAA,EAAekC,cAAcV,MAAAA,EAAQE,YAAAA,CAAAA;IAEvG,MAAMU,MAAAA,GAASpB,QAAQqB,IAAI,CAAChB,CAAAA,SAAAA,GAAaA,SAAAA,CAAUC,IAAI,KAAKQ,UAAAA,CAAWQ,aAAa,KAAKtB,OAAAA,CAAQqB,IAAI,CAAChB,CAAAA,SAAAA,GAAaA,SAAAA,CAAUC,IAAI,KAAKtB,aAAAA,CAAAA,IAAkBgB,OAAO,CAAC,CAAA,CAAE;IAClK,MAAMuB,QAAAA,GAAW1B,QAAQ,IAAMuB,MAAAA,GAASI,yBAAyB7C,WAAAA,EAAayC,MAAAA,EAAQxC,eAAe6C,SAAAA,EAAW;AAAC9C,QAAAA,WAAAA;AAAaC,QAAAA,WAAAA;AAAawC,QAAAA;AAAO,KAAA,CAAA;IAClJ,MAAMM,aAAAA,GAAgB7B,OAAAA,CAAQ,KAAO;YAAEG,OAAAA,EAASC,aAAAA;AAAenB,YAAAA;AAAS,SAAA,CAAA,EAAI;AAACmB,QAAAA,aAAAA;AAAenB,QAAAA;AAAS,KAAA,CAAA;AAErG,IAAA,MAAM6C,cAAAA,GAAiBb,UAAAA,CAAWc,aAAa,GAAGjD,YAAYkD,eAAe,EAAER,IAAAA,CAAKhB,CAAAA,YAAaA,SAAAA,CAAUC,IAAI,KAAKQ,UAAAA,CAAWc,aAAa,CAAA,GAAIH,SAAAA;IAChJ,MAAMK,WAAAA,GAAc,CAACH,cAAAA,IAAkBb,UAAAA,CAAWc,aAAa,IAAIG,qBAAAA,CAAsBjB,UAAAA,CAAWkB,uBAAuB,CAAA,KAAMP,SAAAA;AACjI,IAAA,MAAMQ,aAAaF,qBAAAA,CAAsBjB,UAAAA,CAAWkB,uBAAuB,CAAA,EAAGE,KAAAA,IAASpB,WAAWc,aAAa;AAE/G,IAAA,MAAMO,aAAAA,GAAgBR,cAAAA,GAAiBS,aAAAA,CAAczD,WAAAA,EAAagD,gBAAgB/C,WAAAA,CAAAA,GAAe6C,SAAAA;AAEjG,IAAA,MAAMY,IAAAA,iBACFC,IAAA,CAAAC,QAAA,EAAA;;0BACIC,GAAA,CAACC,KAAAA,EAAAA;gBAAIC,mBAAAA,EAAkB,SAAA;AAAUC,gBAAAA,gBAAAA,EAAgB7B,WAAW8B,UAAU;AAAEC,gBAAAA,mBAAAA,EAAmB/B,WAAWQ,aAAa;AAC9GC,gBAAAA,QAAAA,EAAAA,QAAAA,kBAAYiB,GAAA,CAACM,KAAAA,EAAAA;8BAAO1D,YAAAA,GACf,IAAMA,YAAAA,CAAamC,QAAAA,CAASwB,OAAO,EAAExB,SAASyB,aAAa,EAAElC,UAAAA,CAAAA,GAC7D,kBAAM0B,GAAA,CAACS,gBAAAA,EAAAA;AAAiBF,4BAAAA,OAAAA,EAASxB,SAASwB,OAAO;4BAAEjE,QAAAA,EAAUA,QAAAA;4BAAUI,cAAAA,EAAgBA,cAAAA;4BAAgBC,YAAAA,EAAcA,YAAAA;AAAc6D,4BAAAA,aAAAA,EAAezB,SAASyB;;;;YAEpKrB,cAAAA,IAAkBQ,aAAAA,KAAkB7C,oBAAAA,iBAC/BkD,GAAA,CAACM,KAAAA,EAAAA;0BAAO,IAAMxD,oBAAAA,CAAqBqC,gBAAgBQ,aAAAA,EAAerB,UAAAA;+BAEhE0B,GAAA,CAACC,KAAAA,EAAAA;gBAAIS,IAAAA,EAAK,QAAA;gBAASC,YAAAA,EAAW,MAAA;gBAAOC,YAAAA,EAAYnB,UAAAA;AAAYoB,gBAAAA,mBAAAA,EAAmBvC,WAAWc,aAAa;AACpG,gBAAA,QAAA,gBAAAY,GAAA,CAACS,gBAAAA,EAAAA;oBAAiBF,OAAAA,EAASZ,aAAAA;oBAAerD,QAAAA,EAAUA,QAAAA;oBAAUI,cAAAA,EAAgBA,cAAAA;oBAAgBC,YAAAA,EAAcA;;AAEpH,aAAA,CAAA,CAAA;AACH2C,YAAAA,WAAAA,kBACGU,GAAA,CAACC,KAAAA,EAAAA;gBAAIS,IAAAA,EAAK,QAAA;gBAASC,YAAAA,EAAW,MAAA;gBAAOC,YAAAA,EAAYnB,UAAAA;AAAYoB,gBAAAA,mBAAAA,EAAmBvC,WAAWc,aAAa;AACnGvC,gBAAAA,QAAAA,EAAAA,YAAAA,GAAeyB,6BAAe0B,GAAA,CAACc,eAAAA,EAAAA,EAAAA;;;;AAMhD,IAAA,qBACId,GAAA,CAACe,uBAAAA,EAAAA;QAAwBC,KAAAA,EAAO1C,UAAAA;gCAC5B0B,GAAA,CAACiB,mBAAmBC,QAAQ,EAAA;YAACF,KAAAA,EAAO9B,aAAAA;AAChC,YAAA,QAAA,gBAAAc,GAAA,CAACmB,4BAAAA,EAAAA;gBAA6BC,KAAAA,EAAO/E,eAAAA;AAEjC,gBAAA,QAAA,gBAAAyD,IAAA,CAACuB,oBAAAA,EAAAA;oBAAqBC,OAAAA,EAAStE,mBAAAA;;wBAC1BD,KAAAA,GAAQA,KAAAA,CAAMuB,YAAYuB,IAAAA,CAAAA,GAAQA,IAAAA;AAClC5C,wBAAAA;;;;;;AAMzB;AAEA,4HACA,SAASqD,KAAAA,CAAM,EAAErD,QAAQ,EAA6B,EAAA;IAClD,qBAAO+C,GAAA,CAAAD,QAAA,EAAA;AAAG9C,QAAAA,QAAAA,EAAAA,QAAAA;;AACd;;"}

package/dist/esm/preview-host/FlowArrangementView.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+import { type FlowNode } from '@cratis/scene.model';
+export declare function FlowArrangementView({ node, slots }: {
+    node: FlowNode;
+    slots: Record<string, ReactNode>;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=FlowArrangementView.d.ts.map

package/dist/esm/preview-host/FlowArrangementView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowArrangementView.d.ts","sourceRoot":"","sources":["../../../preview-host/FlowArrangementView.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAevE,wBAAgB,mBAAmB,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAAE,sCA4BxG"}

package/dist/esm/preview-host/FlowArrangementView.js

@@ -0,0 +1,73 @@
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { FlowContainerKind } from '@cratis/scene.model';
+import { isFlowSlotLeaf, isFlowGrid, isFlowContainer } from '@cratis/scene.engine';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Renders a {@link FlowNode} tree - the same one `evaluateFlowArrangement` picks for the current size
+ * class - by walking it into nested flex/grid containers and dropping each named slot's real content into
+ * its {@link FlowSlotLeaf}. This is what turns a modeled `arrangement flow` (a layout's topbar/sidebar/
+ * content/footer, or a screen template's header/body/aside) into something that actually looks like more
+ * than one column, rather than every slot's content stacked flat regardless of what the document said.
+ *
+ * A fixed `width`/`height` on a slot is a known, documented gap in the arrangement it is fed (see
+ * the Screenplay converter) - only `grow` and `span` survive conversion. A slot that does not grow
+ * therefore sizes to its own content here, which is a reasonable rendering of "not growing" even though
+ * the exact pixel the author wrote is not carried this far yet.
+ */ function FlowArrangementView({ node, slots }) {
+    if (isFlowSlotLeaf(node)) {
+        return /*#__PURE__*/ jsx(Fragment, {
+            children: slots[node.slotName] ?? null
+        });
+    }
+    if (isFlowGrid(node)) {
+        const style = {
+            gap: `${node.gap}px`,
+            gridTemplateColumns: node.columns ? `repeat(${node.columns}, 1fr)` : undefined,
+            gridTemplateRows: node.rows ? `repeat(${node.rows}, 1fr)` : undefined
+        };
+        return /*#__PURE__*/ jsx("div", {
+            className: "flow-container flow-container--grid",
+            style: style,
+            children: node.children.map((child, index)=>/*#__PURE__*/ jsx(FlowChild, {
+                    node: child,
+                    slots: slots
+                }, index))
+        });
+    }
+    if (isFlowContainer(node)) {
+        const direction = node.kind === FlowContainerKind.Row ? 'row' : 'column';
+        return /*#__PURE__*/ jsx("div", {
+            className: `flow-container flow-container--${direction}`,
+            style: {
+                gap: `${node.gap}px`
+            },
+            children: node.children.map((child, index)=>/*#__PURE__*/ jsx(FlowChild, {
+                    node: child,
+                    slots: slots
+                }, index))
+        });
+    }
+    return null;
+}
+function FlowChild({ node, slots }) {
+    const style = node.grow ? {
+        flex: `${node.grow} 1 0%`,
+        minWidth: 0,
+        minHeight: 0
+    } : {
+        flex: '0 0 auto'
+    };
+    return /*#__PURE__*/ jsx("div", {
+        className: "flow-child",
+        style: style,
+        children: /*#__PURE__*/ jsx(FlowArrangementView, {
+            node: node,
+            slots: slots
+        })
+    });
+}
+
+export { FlowArrangementView };
+//# sourceMappingURL=FlowArrangementView.js.map

package/dist/esm/preview-host/FlowArrangementView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowArrangementView.js","sources":["../../../preview-host/FlowArrangementView.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport type { CSSProperties, ReactNode } from 'react';\nimport { FlowContainerKind, type FlowNode } from '@cratis/scene.model';\nimport { isFlowContainer, isFlowGrid, isFlowSlotLeaf } from '@cratis/scene.engine';\n\n/**\n * Renders a {@link FlowNode} tree - the same one `evaluateFlowArrangement` picks for the current size\n * class - by walking it into nested flex/grid containers and dropping each named slot's real content into\n * its {@link FlowSlotLeaf}. This is what turns a modeled `arrangement flow` (a layout's topbar/sidebar/\n * content/footer, or a screen template's header/body/aside) into something that actually looks like more\n * than one column, rather than every slot's content stacked flat regardless of what the document said.\n *\n * A fixed `width`/`height` on a slot is a known, documented gap in the arrangement it is fed (see\n * the Screenplay converter) - only `grow` and `span` survive conversion. A slot that does not grow\n * therefore sizes to its own content here, which is a reasonable rendering of \"not growing\" even though\n * the exact pixel the author wrote is not carried this far yet.\n */\nexport function FlowArrangementView({ node, slots }: { node: FlowNode; slots: Record<string, ReactNode> }) {\n    if (isFlowSlotLeaf(node)) {\n        return <>{slots[node.slotName] ?? null}</>;\n    }\n\n    if (isFlowGrid(node)) {\n        const style: CSSProperties = {\n            gap: `${node.gap}px`,\n            gridTemplateColumns: node.columns ? `repeat(${node.columns}, 1fr)` : undefined,\n            gridTemplateRows: node.rows ? `repeat(${node.rows}, 1fr)` : undefined,\n        };\n        return (\n            <div className='flow-container flow-container--grid' style={style}>\n                {node.children.map((child, index) => <FlowChild key={index} node={child} slots={slots} />)}\n            </div>\n        );\n    }\n\n    if (isFlowContainer(node)) {\n        const direction = node.kind === FlowContainerKind.Row ? 'row' : 'column';\n        return (\n            <div className={`flow-container flow-container--${direction}`} style={{ gap: `${node.gap}px` }}>\n                {node.children.map((child, index) => <FlowChild key={index} node={child} slots={slots} />)}\n            </div>\n        );\n    }\n\n    return null;\n}\n\nfunction FlowChild({ node, slots }: { node: FlowNode; slots: Record<string, ReactNode> }) {\n    const style: CSSProperties = node.grow\n        ? { flex: `${node.grow} 1 0%`, minWidth: 0, minHeight: 0 }\n        : { flex: '0 0 auto' };\n    return (\n        <div className='flow-child' style={style}>\n            <FlowArrangementView node={node} slots={slots} />\n        </div>\n    );\n}\n"],"names":["FlowArrangementView","node","slots","isFlowSlotLeaf","_jsx","_Fragment","slotName","isFlowGrid","style","gap","gridTemplateColumns","columns","undefined","gridTemplateRows","rows","div","className","children","map","child","index","FlowChild","isFlowContainer","direction","kind","FlowContainerKind","Row","grow","flex","minWidth","minHeight"],"mappings":";;;;AAAA;AACA;AAMA;;;;;;;;;;;AAWC,IACM,SAASA,mBAAAA,CAAoB,EAAEC,IAAI,EAAEC,KAAK,EAAwD,EAAA;AACrG,IAAA,IAAIC,eAAeF,IAAAA,CAAAA,EAAO;QACtB,qBAAOG,GAAA,CAAAC,QAAA,EAAA;AAAGH,YAAAA,QAAAA,EAAAA,KAAK,CAACD,IAAAA,CAAKK,QAAQ,CAAC,IAAI;;AACtC,IAAA;AAEA,IAAA,IAAIC,WAAWN,IAAAA,CAAAA,EAAO;AAClB,QAAA,MAAMO,KAAAA,GAAuB;AACzBC,YAAAA,GAAAA,EAAK,CAAA,EAAGR,IAAAA,CAAKQ,GAAG,CAAC,EAAE,CAAC;YACpBC,mBAAAA,EAAqBT,IAAAA,CAAKU,OAAO,GAAG,CAAC,OAAO,EAAEV,IAAAA,CAAKU,OAAO,CAAC,MAAM,CAAC,GAAGC,SAAAA;YACrEC,gBAAAA,EAAkBZ,IAAAA,CAAKa,IAAI,GAAG,CAAC,OAAO,EAAEb,IAAAA,CAAKa,IAAI,CAAC,MAAM,CAAC,GAAGF;AAChE,SAAA;AACA,QAAA,qBACIR,GAAA,CAACW,KAAAA,EAAAA;YAAIC,SAAAA,EAAU,qCAAA;YAAsCR,KAAAA,EAAOA,KAAAA;AACvDP,YAAAA,QAAAA,EAAAA,IAAAA,CAAKgB,QAAQ,CAACC,GAAG,CAAC,CAACC,KAAAA,EAAOC,sBAAUhB,GAAA,CAACiB,SAAAA,EAAAA;oBAAsBpB,IAAAA,EAAMkB,KAAAA;oBAAOjB,KAAAA,EAAOA;AAA3BkB,iBAAAA,EAAAA,KAAAA,CAAAA;;AAGjE,IAAA;AAEA,IAAA,IAAIE,gBAAgBrB,IAAAA,CAAAA,EAAO;AACvB,QAAA,MAAMsB,YAAYtB,IAAAA,CAAKuB,IAAI,KAAKC,iBAAAA,CAAkBC,GAAG,GAAG,KAAA,GAAQ,QAAA;AAChE,QAAA,qBACItB,GAAA,CAACW,KAAAA,EAAAA;YAAIC,SAAAA,EAAW,CAAC,+BAA+B,EAAEO,SAAAA,CAAAA,CAAW;YAAEf,KAAAA,EAAO;AAAEC,gBAAAA,GAAAA,EAAK,CAAA,EAAGR,IAAAA,CAAKQ,GAAG,CAAC,EAAE;AAAE,aAAA;AACxFR,YAAAA,QAAAA,EAAAA,IAAAA,CAAKgB,QAAQ,CAACC,GAAG,CAAC,CAACC,KAAAA,EAAOC,sBAAUhB,GAAA,CAACiB,SAAAA,EAAAA;oBAAsBpB,IAAAA,EAAMkB,KAAAA;oBAAOjB,KAAAA,EAAOA;AAA3BkB,iBAAAA,EAAAA,KAAAA,CAAAA;;AAGjE,IAAA;IAEA,OAAO,IAAA;AACX;AAEA,SAASC,SAAAA,CAAU,EAAEpB,IAAI,EAAEC,KAAK,EAAwD,EAAA;IACpF,MAAMM,KAAAA,GAAuBP,IAAAA,CAAK0B,IAAI,GAChC;AAAEC,QAAAA,IAAAA,EAAM,CAAA,EAAG3B,IAAAA,CAAK0B,IAAI,CAAC,KAAK,CAAC;QAAEE,QAAAA,EAAU,CAAA;QAAGC,SAAAA,EAAW;KAAE,GACvD;QAAEF,IAAAA,EAAM;AAAW,KAAA;AACzB,IAAA,qBACIxB,GAAA,CAACW,KAAAA,EAAAA;QAAIC,SAAAA,EAAU,YAAA;QAAaR,KAAAA,EAAOA,KAAAA;AAC/B,QAAA,QAAA,gBAAAJ,GAAA,CAACJ,mBAAAA,EAAAA;YAAoBC,IAAAA,EAAMA,IAAAA;YAAMC,KAAAA,EAAOA;;;AAGpD;;"}

package/dist/esm/preview-host/PreviewProblem.d.ts

@@ -0,0 +1,26 @@
+export declare enum PreviewProblemCode {
+    TargetNotFound = "targetNotFound",
+    ModuleWithoutFeatures = "moduleWithoutFeatures",
+    ScreenMissing = "screenMissing",
+    SliceNotPreviewable = "sliceNotPreviewable",
+    SliceFragmentMissing = "sliceFragmentMissing",
+    LayoutMissing = "layoutMissing",
+    TemplateMissing = "templateMissing",
+    TemplateUnplaced = "templateUnplaced",
+    StructureInvalid = "structureInvalid",
+    NavigationInvalid = "navigationInvalid",
+    ToolbarInvalid = "toolbarInvalid",
+    SampleDataInvalid = "sampleDataInvalid"
+}
+export declare enum PreviewProblemSeverity {
+    Error = "error",
+    Warning = "warning"
+}
+export interface PreviewProblem {
+    code: PreviewProblemCode;
+    severity: PreviewProblemSeverity;
+    message: string;
+    nodeId?: string;
+}
+export declare function hasBlockingProblem(problems: PreviewProblem[]): boolean;
+//# sourceMappingURL=PreviewProblem.d.ts.map

package/dist/esm/preview-host/PreviewProblem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewProblem.d.ts","sourceRoot":"","sources":["../../../preview-host/PreviewProblem.ts"],"names":[],"mappings":"AAIA,oBAAY,kBAAkB;IAE1B,cAAc,mBAAmB;IAGjC,qBAAqB,0BAA0B;IAG/C,aAAa,kBAAkB;IAG/B,mBAAmB,wBAAwB;IAG3C,oBAAoB,yBAAyB;IAG7C,aAAa,kBAAkB;IAG/B,eAAe,oBAAoB;IAGnC,gBAAgB,qBAAqB;IAGrC,gBAAgB,qBAAqB;IAGrC,iBAAiB,sBAAsB;IAGvC,cAAc,mBAAmB;IAGjC,iBAAiB,sBAAsB;CAC1C;AAGD,oBAAY,sBAAsB;IAE9B,KAAK,UAAU;IAGf,OAAO,YAAY;CACtB;AAMD,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,sBAAsB,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAGhB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAGD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,OAAO,CAEtE"}

package/dist/esm/preview-host/PreviewProblem.js

@@ -0,0 +1,28 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** Why a preview could not be rendered, or rendered with a caveat. */ var PreviewProblemCode = /*#__PURE__*/ function(PreviewProblemCode) {
+    /** The module, feature or slice the preview was asked for is not in the application structure. */ PreviewProblemCode["TargetNotFound"] = "targetNotFound";
+    /** The module has no feature to show. */ PreviewProblemCode["ModuleWithoutFeatures"] = "moduleWithoutFeatures";
+    /** The feature the preview shows has no screen in the document. */ PreviewProblemCode["ScreenMissing"] = "screenMissing";
+    /** The slice is neither a State Change nor a State View, so there is nothing to preview. */ PreviewProblemCode["SliceNotPreviewable"] = "sliceNotPreviewable";
+    /** A State View slice's data fragment was not found, so its feature's page is shown. */ PreviewProblemCode["SliceFragmentMissing"] = "sliceFragmentMissing";
+    /** The layout a screen names is neither in the document nor one the blueprint provides. */ PreviewProblemCode["LayoutMissing"] = "layoutMissing";
+    /** The screen template a screen names is neither in the document nor one the blueprint provides. */ PreviewProblemCode["TemplateMissing"] = "templateMissing";
+    /** A template found no single home in the layout, or nests inside itself. */ PreviewProblemCode["TemplateUnplaced"] = "templateUnplaced";
+    /** The application structure has a duplicate or ambiguous id. */ PreviewProblemCode["StructureInvalid"] = "structureInvalid";
+    /** A navigation item leads nowhere or collides with another (the engine's navigation diagnostics). */ PreviewProblemCode["NavigationInvalid"] = "navigationInvalid";
+    /** A toolbar button's slice does not exist, is not a State Change or is empty (the engine's toolbar diagnostics). */ PreviewProblemCode["ToolbarInvalid"] = "toolbarInvalid";
+    /** The profile's sample data selection names a pack or set that does not exist. */ PreviewProblemCode["SampleDataInvalid"] = "sampleDataInvalid";
+    return PreviewProblemCode;
+}({});
+/** How a problem affects the preview. */ var PreviewProblemSeverity = /*#__PURE__*/ function(PreviewProblemSeverity) {
+    /** The preview cannot show what was asked for; the problems are shown instead of a blank screen. */ PreviewProblemSeverity["Error"] = "error";
+    /** The preview renders, but something in the model will not behave as authored. */ PreviewProblemSeverity["Warning"] = "warning";
+    return PreviewProblemSeverity;
+}({});
+/** Whether any of the problems stops the preview from rendering. */ function hasBlockingProblem(problems) {
+    return problems.some((problem)=>problem.severity === "error");
+}
+
+export { PreviewProblemCode, PreviewProblemSeverity, hasBlockingProblem };
+//# sourceMappingURL=PreviewProblem.js.map

package/dist/esm/preview-host/PreviewProblem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewProblem.js","sources":["../../../preview-host/PreviewProblem.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/** Why a preview could not be rendered, or rendered with a caveat. */\nexport enum PreviewProblemCode {\n    /** The module, feature or slice the preview was asked for is not in the application structure. */\n    TargetNotFound = 'targetNotFound',\n\n    /** The module has no feature to show. */\n    ModuleWithoutFeatures = 'moduleWithoutFeatures',\n\n    /** The feature the preview shows has no screen in the document. */\n    ScreenMissing = 'screenMissing',\n\n    /** The slice is neither a State Change nor a State View, so there is nothing to preview. */\n    SliceNotPreviewable = 'sliceNotPreviewable',\n\n    /** A State View slice's data fragment was not found, so its feature's page is shown. */\n    SliceFragmentMissing = 'sliceFragmentMissing',\n\n    /** The layout a screen names is neither in the document nor one the blueprint provides. */\n    LayoutMissing = 'layoutMissing',\n\n    /** The screen template a screen names is neither in the document nor one the blueprint provides. */\n    TemplateMissing = 'templateMissing',\n\n    /** A template found no single home in the layout, or nests inside itself. */\n    TemplateUnplaced = 'templateUnplaced',\n\n    /** The application structure has a duplicate or ambiguous id. */\n    StructureInvalid = 'structureInvalid',\n\n    /** A navigation item leads nowhere or collides with another (the engine's navigation diagnostics). */\n    NavigationInvalid = 'navigationInvalid',\n\n    /** A toolbar button's slice does not exist, is not a State Change or is empty (the engine's toolbar diagnostics). */\n    ToolbarInvalid = 'toolbarInvalid',\n\n    /** The profile's sample data selection names a pack or set that does not exist. */\n    SampleDataInvalid = 'sampleDataInvalid',\n}\n\n/** How a problem affects the preview. */\nexport enum PreviewProblemSeverity {\n    /** The preview cannot show what was asked for; the problems are shown instead of a blank screen. */\n    Error = 'error',\n\n    /** The preview renders, but something in the model will not behave as authored. */\n    Warning = 'warning',\n}\n\n/**\n * One problem the preview found (PRV8): what it is, where, and a sentence an author can act on. The node id is what a host\n * links to - a screen, a template, a navigation item, a toolbar button, a module, feature or slice.\n */\nexport interface PreviewProblem {\n    code: PreviewProblemCode;\n    severity: PreviewProblemSeverity;\n    message: string;\n\n    /** The model node the problem is about, when it has one. */\n    nodeId?: string;\n}\n\n/** Whether any of the problems stops the preview from rendering. */\nexport function hasBlockingProblem(problems: PreviewProblem[]): boolean {\n    return problems.some(problem => problem.severity === PreviewProblemSeverity.Error);\n}\n"],"names":["PreviewProblemCode","PreviewProblemSeverity","hasBlockingProblem","problems","some","problem","severity"],"mappings":"AAAA;AACA;AAEA,uEACO,IAAKA,kBAAAA,iBAAAA,SAAAA,kBAAAA,EAAAA;uGACwF,kBAAA,CAAA,gBAAA,CAAA,GAAA,gBAAA;8CAGzD,kBAAA,CAAA,uBAAA,CAAA,GAAA,uBAAA;wEAG0B,kBAAA,CAAA,eAAA,CAAA,GAAA,eAAA;iGAGyB,kBAAA,CAAA,qBAAA,CAAA,GAAA,qBAAA;6FAGJ,kBAAA,CAAA,sBAAA,CAAA,GAAA,sBAAA;gGAGG,kBAAA,CAAA,eAAA,CAAA,GAAA,eAAA;yGAGS,kBAAA,CAAA,iBAAA,CAAA,GAAA,iBAAA;kFAGvB,kBAAA,CAAA,kBAAA,CAAA,GAAA,kBAAA;sEAGZ,kBAAA,CAAA,kBAAA,CAAA,GAAA,kBAAA;2GAGqC,kBAAA,CAAA,mBAAA,CAAA,GAAA,mBAAA;0HAGe,kBAAA,CAAA,gBAAA,CAAA,GAAA,gBAAA;wFAGlC,kBAAA,CAAA,mBAAA,CAAA,GAAA,mBAAA;AAlCzEA,IAAAA,OAAAA,kBAAAA;AAoCX,CAAA,CAAA,EAAA;AAED,0CACO,IAAKC,sBAAAA,iBAAAA,SAAAA,sBAAAA,EAAAA;yGAC0F,sBAAA,CAAA,OAAA,CAAA,GAAA,OAAA;wFAGjB,sBAAA,CAAA,SAAA,CAAA,GAAA,SAAA;AAJzEA,IAAAA,OAAAA,sBAAAA;AAMX,CAAA,CAAA,EAAA;AAeD,qEACO,SAASC,kBAAAA,CAAmBC,QAA0B,EAAA;AACzD,IAAA,OAAOA,SAASC,IAAI,CAACC,CAAAA,OAAAA,GAAWA,QAAQC,QAAQ,KAAA,OAAA,CAAA;AACpD;;"}

package/dist/esm/preview-host/PreviewProblemsView.d.ts

@@ -0,0 +1,7 @@
+import { PreviewProblem } from './PreviewProblem';
+export interface PreviewProblemsViewProps {
+    problems: PreviewProblem[];
+    onSelectProblem?(problem: PreviewProblem): void;
+}
+export declare function PreviewProblemsView({ problems, onSelectProblem }: PreviewProblemsViewProps): import("react").JSX.Element;
+//# sourceMappingURL=PreviewProblemsView.d.ts.map

package/dist/esm/preview-host/PreviewProblemsView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewProblemsView.d.ts","sourceRoot":"","sources":["../../../preview-host/PreviewProblemsView.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,WAAW,wBAAwB;IACrC,QAAQ,EAAE,cAAc,EAAE,CAAC;IAG3B,eAAe,CAAC,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;CACnD;AAMD,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,eAAe,EAAE,EAAE,wBAAwB,+BAc1F"}

package/dist/esm/preview-host/PreviewProblemsView.js

@@ -0,0 +1,49 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * What a preview shows instead of a blank screen when the model has errors that would break rendering (PRV8): each problem
+ * with its code, its message and a link to the offending node.
+ */ function PreviewProblemsView({ problems, onSelectProblem }) {
+    return /*#__PURE__*/ jsxs("section", {
+        className: "scene-preview-problems",
+        role: "alert",
+        "data-scene-preview-problems": true,
+        children: [
+            /*#__PURE__*/ jsx("h2", {
+                children: "This preview cannot be shown"
+            }),
+            /*#__PURE__*/ jsx("ul", {
+                children: problems.map((problem, index)=>/*#__PURE__*/ jsxs("li", {
+                        "data-severity": problem.severity,
+                        "data-code": problem.code,
+                        "data-node-id": problem.nodeId,
+                        children: [
+                            /*#__PURE__*/ jsx("code", {
+                                children: problem.code
+                            }),
+                            " ",
+                            problem.message,
+                            problem.nodeId !== undefined && onSelectProblem && /*#__PURE__*/ jsxs(Fragment, {
+                                children: [
+                                    " ",
+                                    /*#__PURE__*/ jsxs("button", {
+                                        type: "button",
+                                        onClick: ()=>onSelectProblem(problem),
+                                        children: [
+                                            "Show ",
+                                            problem.nodeId
+                                        ]
+                                    })
+                                ]
+                            })
+                        ]
+                    }, `${problem.code}-${problem.nodeId ?? index}-${index}`))
+            })
+        ]
+    });
+}
+
+export { PreviewProblemsView };
+//# sourceMappingURL=PreviewProblemsView.js.map

package/dist/esm/preview-host/PreviewProblemsView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewProblemsView.js","sources":["../../../preview-host/PreviewProblemsView.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { PreviewProblem } from './PreviewProblem';\n\nexport interface PreviewProblemsViewProps {\n    problems: PreviewProblem[];\n\n    /** Called when the author follows a problem to the node it is about. */\n    onSelectProblem?(problem: PreviewProblem): void;\n}\n\n/**\n * What a preview shows instead of a blank screen when the model has errors that would break rendering (PRV8): each problem\n * with its code, its message and a link to the offending node.\n */\nexport function PreviewProblemsView({ problems, onSelectProblem }: PreviewProblemsViewProps) {\n    return (\n        <section className='scene-preview-problems' role='alert' data-scene-preview-problems>\n            <h2>This preview cannot be shown</h2>\n            <ul>\n                {problems.map((problem, index) => (\n                    <li key={`${problem.code}-${problem.nodeId ?? index}-${index}`} data-severity={problem.severity} data-code={problem.code} data-node-id={problem.nodeId}>\n                        <code>{problem.code}</code> {problem.message}\n                        {problem.nodeId !== undefined && onSelectProblem && <> <button type='button' onClick={() => onSelectProblem(problem)}>Show {problem.nodeId}</button></>}\n                    </li>\n                ))}\n            </ul>\n        </section>\n    );\n}\n"],"names":["PreviewProblemsView","problems","onSelectProblem","_jsxs","section","className","role","data-scene-preview-problems","_jsx","h2","ul","map","problem","index","li","data-severity","severity","data-code","code","data-node-id","nodeId","message","undefined","_Fragment","button","type","onClick"],"mappings":";;AAAA;AACA;AAWA;;;AAGC,IACM,SAASA,mBAAAA,CAAoB,EAAEC,QAAQ,EAAEC,eAAe,EAA4B,EAAA;AACvF,IAAA,qBACIC,IAAA,CAACC,SAAAA,EAAAA;QAAQC,SAAAA,EAAU,wBAAA;QAAyBC,IAAAA,EAAK,OAAA;QAAQC,6BAA2B,EAAA,IAAA;;0BAChFC,GAAA,CAACC,IAAAA,EAAAA;AAAG,gBAAA,QAAA,EAAA;;0BACJD,GAAA,CAACE,IAAAA,EAAAA;AACIT,gBAAAA,QAAAA,EAAAA,QAAAA,CAASU,GAAG,CAAC,CAACC,OAAAA,EAASC,sBACpBV,IAAA,CAACW,IAAAA,EAAAA;AAA+DC,wBAAAA,eAAAA,EAAeH,QAAQI,QAAQ;AAAEC,wBAAAA,WAAAA,EAAWL,QAAQM,IAAI;AAAEC,wBAAAA,cAAAA,EAAcP,QAAQQ,MAAM;;0CAClJZ,GAAA,CAACU,MAAAA,EAAAA;AAAMN,gCAAAA,QAAAA,EAAAA,OAAAA,CAAQM;;AAAY,4BAAA,GAAA;AAAEN,4BAAAA,OAAAA,CAAQS,OAAO;4BAC3CT,OAAAA,CAAQQ,MAAM,KAAKE,SAAAA,IAAapB,eAAAA,kBAAmBC,IAAA,CAAAoB,QAAA,EAAA;;AAAE,oCAAA,GAAA;kDAACpB,IAAA,CAACqB,QAAAA,EAAAA;wCAAOC,IAAAA,EAAK,QAAA;AAASC,wCAAAA,OAAAA,EAAS,IAAMxB,eAAAA,CAAgBU,OAAAA,CAAAA;;AAAU,4CAAA,OAAA;AAAMA,4CAAAA,OAAAA,CAAQQ;;;;;;uBAF/H,CAAA,EAAGR,OAAAA,CAAQM,IAAI,CAAC,CAAC,EAAEN,OAAAA,CAAQQ,MAAM,IAAIP,KAAAA,CAAM,CAAC,EAAEA,KAAAA,CAAAA,CAAO,CAAA;;;;AAQlF;;"}

package/dist/esm/preview-host/PreviewSliceFragment.d.ts

@@ -0,0 +1,3 @@
+import { SceneElement, Screen, SliceNode } from '@cratis/scene.model';
+export declare function findSliceFragment(screen: Screen, sliceId: string, slice: SliceNode): SceneElement[];
+//# sourceMappingURL=PreviewSliceFragment.d.ts.map

package/dist/esm/preview-host/PreviewSliceFragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewSliceFragment.d.ts","sourceRoot":"","sources":["../../../preview-host/PreviewSliceFragment.ts"],"names":[],"mappings":"AAGA,OAAO,EAAqB,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAyBzF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,YAAY,EAAE,CAcnG"}