@cratis/scene.blueprint.default 4.33.0 → 4.34.0

package/dist/cjs/index.js

@@ -31,7 +31,7 @@ var dialogTemplates = require('./gallery/dialogTemplates.js');
 var screens = require('./gallery/screens.js');
 var dependencyComponentNames = require('./gallery/dependencyComponentNames.js');
 var componentNames = require('./gallery/componentNames.js');
-var previewProfile = require('./gallery/previewProfile.js');
+var previewProfile$1 = require('./gallery/previewProfile.js');
 var resolveElementNames = require('./gallery/resolveElementNames.js');
 var GalleryScreenPreview = require('./gallery/GalleryScreenPreview.js');
 var TemplatePreviewState = require('./gallery/TemplatePreviewState.js');
@@ -86,6 +86,23 @@ var LayoutThemeProvider = require('./themes/LayoutThemeProvider.js');
 var defaultBlueprintComponents = require('./defaultBlueprintComponents.js');
 var defaultBlueprint = require('./defaultBlueprint.js');
 var templateProvenance = require('./templateProvenance.js');
+var PreviewTarget = require('./preview-host/PreviewTarget.js');
+var PreviewProblem = require('./preview-host/PreviewProblem.js');
+var ApplicationDocument = require('./preview-host/ApplicationDocument.js');
+var previewProfile = require('./preview-host/previewProfile.js');
+var defaultApplicationChrome = require('./preview-host/defaultApplicationChrome.js');
+var FlowArrangementView = require('./preview-host/FlowArrangementView.js');
+var useSizeClass = require('./preview-host/useSizeClass.js');
+var PreviewTemplate = require('./preview-host/PreviewTemplate.js');
+var composeApplication = require('./preview-host/composeApplication.js');
+var resolvePreviewPlan = require('./preview-host/resolvePreviewPlan.js');
+var diagnosePreview = require('./preview-host/diagnosePreview.js');
+var previewSampleData = require('./preview-host/previewSampleData.js');
+var PreviewSliceFragment = require('./preview-host/PreviewSliceFragment.js');
+var PreviewToast = require('./preview-host/PreviewToast.js');
+var PreviewProblemsView = require('./preview-host/PreviewProblemsView.js');
+var ApplicationHost = require('./preview-host/ApplicationHost.js');
+var ScenePreviewHost = require('./preview-host/ScenePreviewHost.js');
 
 
 
@@ -205,9 +222,9 @@ exports.cratisComponentsNames = dependencyComponentNames.cratisComponentsNames;
 exports.primeReactComponentNames = dependencyComponentNames.primeReactComponentNames;
 exports.componentNamesIn = componentNames.componentNamesIn;
 exports.distinctComponentNames = componentNames.distinctComponentNames;
-exports.galleryComponentCatalog = previewProfile.galleryComponentCatalog;
-exports.galleryPreviewProfile = previewProfile.galleryPreviewProfile;
-exports.galleryProfile = previewProfile.galleryProfile;
+exports.galleryComponentCatalog = previewProfile$1.galleryComponentCatalog;
+exports.galleryPreviewProfile = previewProfile$1.galleryPreviewProfile;
+exports.galleryProfile = previewProfile$1.galleryProfile;
 exports.resolveElementComponentNames = resolveElementNames.resolveElementComponentNames;
 exports.GalleryScreenPreview = GalleryScreenPreview.GalleryScreenPreview;
 exports.galleryPreviewRegistry = GalleryScreenPreview.galleryPreviewRegistry;
@@ -317,4 +334,36 @@ exports.defaultBlueprint = defaultBlueprint.defaultBlueprint;
 exports.defaultBlueprintManifest = defaultBlueprint.defaultBlueprintManifest;
 exports.defaultBlueprintTemplateProvenance = templateProvenance.defaultBlueprintTemplateProvenance;
 exports.sakaiCompositionProvenance = templateProvenance.sakaiCompositionProvenance;
+exports.isSliceTarget = PreviewTarget.isSliceTarget;
+exports.PreviewProblemCode = PreviewProblem.PreviewProblemCode;
+exports.PreviewProblemSeverity = PreviewProblem.PreviewProblemSeverity;
+exports.hasBlockingProblem = PreviewProblem.hasBlockingProblem;
+exports.completeDocument = ApplicationDocument.completeDocument;
+exports.blueprintPackageCatalog = previewProfile.blueprintPackageCatalog;
+exports.previewProfile = previewProfile.previewProfile;
+exports.requiredPackages = previewProfile.requiredPackages;
+exports.defaultApplicationChrome = defaultApplicationChrome.defaultApplicationChrome;
+exports.FlowArrangementView = FlowArrangementView.FlowArrangementView;
+exports.useSizeClass = useSizeClass.useSizeClass;
+exports.PreviewTemplate = PreviewTemplate.PreviewTemplate;
+exports.previewComponents = PreviewTemplate.previewComponents;
+exports.previewTemplateComponent = PreviewTemplate.previewTemplateComponent;
+exports.collectDestinations = composeApplication.collectDestinations;
+exports.composeApplicationScreen = composeApplication.composeApplicationScreen;
+exports.composeDialog = composeApplication.composeDialog;
+exports.composeOutletScreen = composeApplication.composeOutletScreen;
+exports.findLayout = composeApplication.findLayout;
+exports.screenContent = composeApplication.screenContent;
+exports.templateChainOf = composeApplication.templateChainOf;
+exports.templatePoolFor = composeApplication.templatePoolFor;
+exports.templatesOf = composeApplication.templatesOf;
+exports.resolvePreviewPlan = resolvePreviewPlan.resolvePreviewPlan;
+exports.diagnosePreview = diagnosePreview.diagnosePreview;
+exports.collectQueryNames = previewSampleData.collectQueryNames;
+exports.createPreviewSampleData = previewSampleData.createPreviewSampleData;
+exports.findSliceFragment = PreviewSliceFragment.findSliceFragment;
+exports.PreviewToast = PreviewToast.PreviewToast;
+exports.PreviewProblemsView = PreviewProblemsView.PreviewProblemsView;
+exports.ApplicationHost = ApplicationHost.ApplicationHost;
+exports.ScenePreviewHost = ScenePreviewHost.ScenePreviewHost;
 //# sourceMappingURL=index.js.map

package/dist/cjs/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/cjs/preview-host/ApplicationDocument.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// 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 ?? []
+    };
+}
+
+exports.completeDocument = completeDocument;
+//# sourceMappingURL=ApplicationDocument.js.map

package/dist/cjs/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/cjs/preview-host/ApplicationHost.js

@@ -0,0 +1,113 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var scene_react = require('@cratis/scene.react');
+var LayoutConfigProvider = require('../configuration/LayoutConfigProvider.js');
+var PreviewTemplate = require('./PreviewTemplate.js');
+var composeApplication = require('./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, children }) {
+    const [memoryHistory] = react.useState(()=>scene_react.createMemorySceneHistory());
+    const registry = react.useMemo(()=>({
+            ...PreviewTemplate.previewComponents,
+            ...hostRegistry
+        }), [
+        hostRegistry
+    ]);
+    const hostHistory = history ?? memoryHistory;
+    const screens = application.screens;
+    const outletScreens = react.useMemo(()=>Object.fromEntries(screens.map((candidate)=>[
+                candidate.name,
+                composeApplication.composeOutletScreen(application, candidate, composition)
+            ])), [
+        application,
+        composition,
+        screens
+    ]);
+    const owners = react.useMemo(()=>scene_react.collectOutletOwners(outletScreens), [
+        outletScreens
+    ]);
+    const destinations = react.useMemo(()=>[
+            ...composeApplication.collectDestinations(application),
+            ...scene_react.navigationDestinations(navigationModel.structure, navigationModel.navigation, navigationModel.screenFor)
+        ], [
+        application,
+        navigationModel
+    ]);
+    const routes = react.useMemo(()=>scene_react.sceneRoutesFrom(screens.map((candidate)=>candidate.name), destinations), [
+        destinations,
+        screens
+    ]);
+    const bindingScope = react.useMemo(()=>({
+            queryResults
+        }), [
+        queryResults
+    ]);
+    const navigation = scene_react.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 = react.useMemo(()=>screen ? composeApplication.composeApplicationScreen(application, screen, composition) : undefined, [
+        application,
+        composition,
+        screen
+    ]);
+    const outletContext = react.useMemo(()=>({
+            screens: outletScreens,
+            registry
+        }), [
+        outletScreens,
+        registry
+    ]);
+    const dialogTemplate = navigation.currentDialog ? application.dialogTemplates?.find((candidate)=>candidate.name === navigation.currentDialog) : undefined;
+    const sliceDialog = !dialogTemplate && navigation.currentDialog && scene_react.sliceDialogParameters(navigation.currentDialogParameters) !== undefined;
+    const dialogName = scene_react.sliceDialogParameters(navigation.currentDialogParameters)?.title ?? navigation.currentDialog;
+    const drawn = composed ? renderScreen?.(composed.element, composed.configuration, navigation) ?? /*#__PURE__*/ jsxRuntime.jsx(scene_react.SceneElementView, {
+        element: composed.element,
+        registry: registry,
+        resolveBinding: resolveBinding,
+        queryResults: queryResults,
+        configuration: composed.configuration
+    }) : null;
+    return /*#__PURE__*/ jsxRuntime.jsx(scene_react.SceneNavigationProvider, {
+        value: navigation,
+        children: /*#__PURE__*/ jsxRuntime.jsx(scene_react.SceneOutletContext.Provider, {
+            value: outletContext,
+            children: /*#__PURE__*/ jsxRuntime.jsx(scene_react.SceneNavigationModelProvider, {
+                model: navigationModel,
+                children: /*#__PURE__*/ jsxRuntime.jsxs(LayoutConfigProvider.LayoutConfigProvider, {
+                    storage: null,
+                    children: [
+                        /*#__PURE__*/ jsxRuntime.jsx("div", {
+                            "data-scene-outlet": "primary",
+                            "data-scene-url": navigation.currentUrl,
+                            "data-scene-screen": navigation.primaryScreen,
+                            children: drawn
+                        }),
+                        (dialogTemplate || sliceDialog) && /*#__PURE__*/ jsxRuntime.jsx("div", {
+                            role: "dialog",
+                            "aria-modal": "true",
+                            "aria-label": dialogName,
+                            "data-scene-dialog": navigation.currentDialog,
+                            children: dialogTemplate ? /*#__PURE__*/ jsxRuntime.jsx(scene_react.SceneElementView, {
+                                element: composeApplication.composeDialog(application, dialogTemplate, composition),
+                                registry: registry,
+                                resolveBinding: resolveBinding,
+                                queryResults: queryResults
+                            }) : renderDialog?.(navigation) ?? /*#__PURE__*/ jsxRuntime.jsx(scene_react.SliceDialogView, {})
+                        }),
+                        children
+                    ]
+                })
+            })
+        })
+    });
+}
+
+exports.ApplicationHost = ApplicationHost;
+//# sourceMappingURL=ApplicationHost.js.map

package/dist/cjs/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 { 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    /** 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, 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 drawn = composed\n        ? renderScreen?.(composed.element, composed.configuration, navigation)\n            ?? <SceneElementView element={composed.element} registry={registry} resolveBinding={resolveBinding} queryResults={queryResults} configuration={composed.configuration} />\n        : null;\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 from a hosted application's own. */}\n                    <LayoutConfigProvider storage={null}>\n                        <div data-scene-outlet='primary' data-scene-url={navigation.currentUrl} data-scene-screen={navigation.primaryScreen}>{drawn}</div>\n                        {(dialogTemplate || sliceDialog) && (\n                            <div role='dialog' aria-modal='true' aria-label={dialogName} data-scene-dialog={navigation.currentDialog}>\n                                {dialogTemplate\n                                    ? <SceneElementView element={composeDialog(application, dialogTemplate, composition)} registry={registry} resolveBinding={resolveBinding} queryResults={queryResults} />\n                                    : renderDialog?.(navigation) ?? <SliceDialogView />}\n                            </div>\n                        )}\n                        {children}\n                    </LayoutConfigProvider>\n                </SceneNavigationModelProvider>\n            </SceneOutletContext.Provider>\n        </SceneNavigationProvider>\n    );\n}\n"],"names":["ApplicationHost","application","composition","navigationModel","registry","hostRegistry","initialScreen","history","resolveBinding","queryResults","renderScreen","renderDialog","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","drawn","element","configuration","_jsx","SceneElementView","SceneNavigationProvider","value","SceneOutletContext","Provider","SceneNavigationModelProvider","model","_jsxs","LayoutConfigProvider","storage","div","data-scene-outlet","data-scene-url","currentUrl","data-scene-screen","role","aria-modal","aria-label","data-scene-dialog","composeDialog","SliceDialogView"],"mappings":"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"}

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

@@ -0,0 +1,75 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var scene_model = require('@cratis/scene.model');
+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.
+/**
+ * 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 (scene_engine.isFlowSlotLeaf(node)) {
+        return /*#__PURE__*/ jsxRuntime.jsx(jsxRuntime.Fragment, {
+            children: slots[node.slotName] ?? null
+        });
+    }
+    if (scene_engine.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__*/ jsxRuntime.jsx("div", {
+            className: "flow-container flow-container--grid",
+            style: style,
+            children: node.children.map((child, index)=>/*#__PURE__*/ jsxRuntime.jsx(FlowChild, {
+                    node: child,
+                    slots: slots
+                }, index))
+        });
+    }
+    if (scene_engine.isFlowContainer(node)) {
+        const direction = node.kind === scene_model.FlowContainerKind.Row ? 'row' : 'column';
+        return /*#__PURE__*/ jsxRuntime.jsx("div", {
+            className: `flow-container flow-container--${direction}`,
+            style: {
+                gap: `${node.gap}px`
+            },
+            children: node.children.map((child, index)=>/*#__PURE__*/ jsxRuntime.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__*/ jsxRuntime.jsx("div", {
+        className: "flow-child",
+        style: style,
+        children: /*#__PURE__*/ jsxRuntime.jsx(FlowArrangementView, {
+            node: node,
+            slots: slots
+        })
+    });
+}
+
+exports.FlowArrangementView = FlowArrangementView;
+//# sourceMappingURL=FlowArrangementView.js.map

package/dist/cjs/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,4BAAeF,IAAAA,CAAAA,EAAO;QACtB,qBAAOG,cAAA,CAAAC,mBAAA,EAAA;AAAGH,YAAAA,QAAAA,EAAAA,KAAK,CAACD,IAAAA,CAAKK,QAAQ,CAAC,IAAI;;AACtC,IAAA;AAEA,IAAA,IAAIC,wBAAWN,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,cAAA,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,cAAA,CAACiB,SAAAA,EAAAA;oBAAsBpB,IAAAA,EAAMkB,KAAAA;oBAAOjB,KAAAA,EAAOA;AAA3BkB,iBAAAA,EAAAA,KAAAA,CAAAA;;AAGjE,IAAA;AAEA,IAAA,IAAIE,6BAAgBrB,IAAAA,CAAAA,EAAO;AACvB,QAAA,MAAMsB,YAAYtB,IAAAA,CAAKuB,IAAI,KAAKC,6BAAAA,CAAkBC,GAAG,GAAG,KAAA,GAAQ,QAAA;AAChE,QAAA,qBACItB,cAAA,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,cAAA,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,cAAA,CAACW,KAAAA,EAAAA;QAAIC,SAAAA,EAAU,YAAA;QAAaR,KAAAA,EAAOA,KAAAA;AAC/B,QAAA,QAAA,gBAAAJ,cAAA,CAACJ,mBAAAA,EAAAA;YAAoBC,IAAAA,EAAMA,IAAAA;YAAMC,KAAAA,EAAOA;;;AAGpD;;"}

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

@@ -0,0 +1,32 @@
+'use strict';
+
+// 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");
+}
+
+exports.PreviewProblemCode = PreviewProblemCode;
+exports.PreviewProblemSeverity = PreviewProblemSeverity;
+exports.hasBlockingProblem = hasBlockingProblem;
+//# sourceMappingURL=PreviewProblem.js.map

package/dist/cjs/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/cjs/preview-host/PreviewProblemsView.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var jsxRuntime = require('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__*/ jsxRuntime.jsxs("section", {
+        className: "scene-preview-problems",
+        role: "alert",
+        "data-scene-preview-problems": true,
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx("h2", {
+                children: "This preview cannot be shown"
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx("ul", {
+                children: problems.map((problem, index)=>/*#__PURE__*/ jsxRuntime.jsxs("li", {
+                        "data-severity": problem.severity,
+                        "data-code": problem.code,
+                        "data-node-id": problem.nodeId,
+                        children: [
+                            /*#__PURE__*/ jsxRuntime.jsx("code", {
+                                children: problem.code
+                            }),
+                            " ",
+                            problem.message,
+                            problem.nodeId !== undefined && onSelectProblem && /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+                                children: [
+                                    " ",
+                                    /*#__PURE__*/ jsxRuntime.jsxs("button", {
+                                        type: "button",
+                                        onClick: ()=>onSelectProblem(problem),
+                                        children: [
+                                            "Show ",
+                                            problem.nodeId
+                                        ]
+                                    })
+                                ]
+                            })
+                        ]
+                    }, `${problem.code}-${problem.nodeId ?? index}-${index}`))
+            })
+        ]
+    });
+}
+
+exports.PreviewProblemsView = PreviewProblemsView;
+//# sourceMappingURL=PreviewProblemsView.js.map

package/dist/cjs/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,eAAA,CAACC,SAAAA,EAAAA;QAAQC,SAAAA,EAAU,wBAAA;QAAyBC,IAAAA,EAAK,OAAA;QAAQC,6BAA2B,EAAA,IAAA;;0BAChFC,cAAA,CAACC,IAAAA,EAAAA;AAAG,gBAAA,QAAA,EAAA;;0BACJD,cAAA,CAACE,IAAAA,EAAAA;AACIT,gBAAAA,QAAAA,EAAAA,QAAAA,CAASU,GAAG,CAAC,CAACC,OAAAA,EAASC,sBACpBV,eAAA,CAACW,IAAAA,EAAAA;AAA+DC,wBAAAA,eAAAA,EAAeH,QAAQI,QAAQ;AAAEC,wBAAAA,WAAAA,EAAWL,QAAQM,IAAI;AAAEC,wBAAAA,cAAAA,EAAcP,QAAQQ,MAAM;;0CAClJZ,cAAA,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,eAAA,CAAAoB,mBAAA,EAAA;;AAAE,oCAAA,GAAA;kDAACpB,eAAA,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/cjs/preview-host/PreviewSliceFragment.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function matches(element, names) {
+    const properties = element.properties;
+    return [
+        'query',
+        'readModel',
+        'slice'
+    ].some((key)=>{
+        const value = properties?.[key];
+        return typeof value === 'string' && (names.has(value) || names.has(value.slice(value.lastIndexOf('.') + 1)));
+    });
+}
+function childrenOf(element) {
+    const node = element;
+    return [
+        ...Object.values(node.slots ?? {}).flat(),
+        ...Array.isArray(node.children) ? node.children : [],
+        ...node.content ? [
+            node.content
+        ] : [],
+        ...node.itemTemplate ? [
+            node.itemTemplate
+        ] : []
+    ];
+}
+/**
+ * The data fragment of a State View slice (PRV3): the outermost components of the slice's screen bound to the slice's read model
+ * or query - by the slice's qualified id, its id, its name or its command - each with everything inside it. Empty when the screen
+ * has nothing bound to it.
+ */ function findSliceFragment(screen, sliceId, slice) {
+    const names = new Set([
+        sliceId,
+        slice.id,
+        slice.name,
+        ...slice.command ? [
+            slice.command
+        ] : []
+    ]);
+    const found = [];
+    const visit = (element)=>{
+        if (element.componentName !== undefined && matches(element, names)) {
+            found.push(element);
+            return;
+        }
+        childrenOf(element).forEach(visit);
+    };
+    Object.values(screen.slotContent).flat().forEach(visit);
+    return found;
+}
+
+exports.findSliceFragment = findSliceFragment;
+//# sourceMappingURL=PreviewSliceFragment.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewSliceFragment.js","sources":["../../../preview-host/PreviewSliceFragment.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 { ExternalComponent, SceneElement, Screen, SliceNode } from '@cratis/scene.model';\n\nfunction matches(element: ExternalComponent, names: Set<string>): boolean {\n    const properties = element.properties as Record<string, unknown> | undefined;\n    return ['query', 'readModel', 'slice'].some(key => {\n        const value = properties?.[key];\n        return typeof value === 'string' && (names.has(value) || names.has(value.slice(value.lastIndexOf('.') + 1)));\n    });\n}\n\nfunction childrenOf(element: SceneElement): SceneElement[] {\n    const node = element as { slots?: Record<string, SceneElement[]>; children?: SceneElement[]; content?: SceneElement; itemTemplate?: SceneElement };\n    return [\n        ...Object.values(node.slots ?? {}).flat(),\n        ...(Array.isArray(node.children) ? node.children : []),\n        ...(node.content ? [node.content] : []),\n        ...(node.itemTemplate ? [node.itemTemplate] : []),\n    ];\n}\n\n/**\n * The data fragment of a State View slice (PRV3): the outermost components of the slice's screen bound to the slice's read model\n * or query - by the slice's qualified id, its id, its name or its command - each with everything inside it. Empty when the screen\n * has nothing bound to it.\n */\nexport function findSliceFragment(screen: Screen, sliceId: string, slice: SliceNode): SceneElement[] {\n    const names = new Set([sliceId, slice.id, slice.name, ...(slice.command ? [slice.command] : [])]);\n    const found: SceneElement[] = [];\n    const visit = (element: SceneElement) => {\n        if ((element as ExternalComponent).componentName !== undefined && matches(element as ExternalComponent, names)) {\n            found.push(element);\n            return;\n        }\n\n        childrenOf(element).forEach(visit);\n    };\n\n    Object.values(screen.slotContent).flat().forEach(visit);\n    return found;\n}\n"],"names":["matches","element","names","properties","some","key","value","has","slice","lastIndexOf","childrenOf","node","Object","values","slots","flat","Array","isArray","children","content","itemTemplate","findSliceFragment","screen","sliceId","Set","id","name","command","found","visit","componentName","undefined","push","forEach","slotContent"],"mappings":";;AAAA;AACA;AAIA,SAASA,OAAAA,CAAQC,OAA0B,EAAEC,KAAkB,EAAA;IAC3D,MAAMC,UAAAA,GAAaF,QAAQE,UAAU;IACrC,OAAO;AAAC,QAAA,OAAA;AAAS,QAAA,WAAA;AAAa,QAAA;KAAQ,CAACC,IAAI,CAACC,CAAAA,GAAAA,GAAAA;QACxC,MAAMC,KAAAA,GAAQH,UAAAA,GAAaE,GAAAA,CAAI;AAC/B,QAAA,OAAO,OAAOC,KAAAA,KAAU,QAAA,KAAaJ,KAAAA,CAAMK,GAAG,CAACD,KAAAA,CAAAA,IAAUJ,KAAAA,CAAMK,GAAG,CAACD,MAAME,KAAK,CAACF,MAAMG,WAAW,CAAC,OAAO,CAAA,CAAA,CAAE,CAAA;AAC9G,IAAA,CAAA,CAAA;AACJ;AAEA,SAASC,WAAWT,OAAqB,EAAA;AACrC,IAAA,MAAMU,IAAAA,GAAOV,OAAAA;IACb,OAAO;AACAW,QAAAA,GAAAA,MAAAA,CAAOC,MAAM,CAACF,IAAAA,CAAKG,KAAK,IAAI,IAAIC,IAAI,EAAA;WACnCC,KAAAA,CAAMC,OAAO,CAACN,IAAAA,CAAKO,QAAQ,IAAIP,IAAAA,CAAKO,QAAQ,GAAG,EAAE;AACjDP,QAAAA,GAAAA,IAAAA,CAAKQ,OAAO,GAAG;AAACR,YAAAA,IAAAA,CAAKQ;AAAQ,SAAA,GAAG,EAAE;AAClCR,QAAAA,GAAAA,IAAAA,CAAKS,YAAY,GAAG;AAACT,YAAAA,IAAAA,CAAKS;AAAa,SAAA,GAAG;AACjD,KAAA;AACL;AAEA;;;;AAIC,IACM,SAASC,iBAAAA,CAAkBC,MAAc,EAAEC,OAAe,EAAEf,KAAgB,EAAA;IAC/E,MAAMN,KAAAA,GAAQ,IAAIsB,GAAAA,CAAI;AAACD,QAAAA,OAAAA;AAASf,QAAAA,KAAAA,CAAMiB,EAAE;AAAEjB,QAAAA,KAAAA,CAAMkB,IAAI;AAAMlB,QAAAA,GAAAA,KAAAA,CAAMmB,OAAO,GAAG;AAACnB,YAAAA,KAAAA,CAAMmB;AAAQ,SAAA,GAAG;AAAI,KAAA,CAAA;AAChG,IAAA,MAAMC,QAAwB,EAAE;AAChC,IAAA,MAAMC,QAAQ,CAAC5B,OAAAA,GAAAA;AACX,QAAA,IAAI,OAACA,CAA8B6B,aAAa,KAAKC,SAAAA,IAAa/B,OAAAA,CAAQC,SAA8BC,KAAAA,CAAAA,EAAQ;AAC5G0B,YAAAA,KAAAA,CAAMI,IAAI,CAAC/B,OAAAA,CAAAA;AACX,YAAA;AACJ,QAAA;QAEAS,UAAAA,CAAWT,OAAAA,CAAAA,CAASgC,OAAO,CAACJ,KAAAA,CAAAA;AAChC,IAAA,CAAA;IAEAjB,MAAAA,CAAOC,MAAM,CAACS,MAAAA,CAAOY,WAAW,EAAEnB,IAAI,EAAA,CAAGkB,OAAO,CAACJ,KAAAA,CAAAA;IACjD,OAAOD,KAAAA;AACX;;"}

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

@@ -0,0 +1,17 @@
+'use strict';
+
+// 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 (spec PRV1/PRV3): a module - the application shell with the module's effective navigation and its
+ * first feature -, one of its features - the same shell with that feature - or a slice. Ids are the qualified ids of the
+ * application structure: `sales`, `sales.orders`, `sales.orders.PlaceOrder`. A feature may also be given relative to its module
+ * (`orders`).
+ *
+ * A State Change slice opens its dialog over a minimal host page; a State View slice renders its data fragment.
+ */ /** Whether a target names a slice. */ function isSliceTarget(target) {
+    return 'slice' in target;
+}
+
+exports.isSliceTarget = isSliceTarget;
+//# sourceMappingURL=PreviewTarget.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewTarget.js","sources":["../../../preview-host/PreviewTarget.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/**\n * What a preview shows (spec PRV1/PRV3): a module - the application shell with the module's effective navigation and its\n * first feature -, one of its features - the same shell with that feature - or a slice. Ids are the qualified ids of the\n * application structure: `sales`, `sales.orders`, `sales.orders.PlaceOrder`. A feature may also be given relative to its module\n * (`orders`).\n *\n * A State Change slice opens its dialog over a minimal host page; a State View slice renders its data fragment.\n */\nexport type PreviewTarget =\n    | { module: string; feature?: string }\n    | { slice: string };\n\n/** Whether a target names a slice. */\nexport function isSliceTarget(target: PreviewTarget): target is { slice: string } {\n    return 'slice' in target;\n}\n"],"names":["isSliceTarget","target"],"mappings":";;AAAA;AACA;AAEA;;;;;;;AAOC,2CAMM,SAASA,cAAcC,MAAqB,EAAA;AAC/C,IAAA,OAAO,OAAA,IAAWA,MAAAA;AACtB;;"}

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

@@ -0,0 +1,49 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var scene_engine = require('@cratis/scene.engine');
+var FlowArrangementView = require('./FlowArrangementView.js');
+var useSizeClass = require('./useSizeClass.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The name the template wrapper is registered under. */ const previewTemplateComponent = 'Scene:template';
+function isFlowArrangement(arrangement) {
+    return !!arrangement && typeof arrangement === 'object' && 'root' in arrangement;
+}
+/**
+ * A screen's content inside the screen template it names.
+ *
+ * The template's own `arrangement flow` positions its slots - header, body, aside - exactly as the document wrote it, evaluated
+ * for the window's current size class. A template with no flow arrangement stacks them. It sits inside the shell's content
+ * slot, so the shell, not this, owns the chrome around it. Stage and the preview host render templates with this one component.
+ */ function PreviewTemplate({ element, slots }) {
+    const sizeClass = useSizeClass.useSizeClass();
+    const arrangement = element.properties?.arrangement;
+    const nodes = {};
+    for (const [name, content] of Object.entries(slots)){
+        nodes[name] = /*#__PURE__*/ jsxRuntime.jsx("section", {
+            className: "scene-template-slot",
+            "data-slot": name,
+            children: content
+        });
+    }
+    return /*#__PURE__*/ jsxRuntime.jsx("div", {
+        className: "scene-template",
+        "data-scene-id": element.id,
+        children: isFlowArrangement(arrangement) ? /*#__PURE__*/ jsxRuntime.jsx(FlowArrangementView.FlowArrangementView, {
+            node: scene_engine.evaluateFlowArrangement(arrangement, sizeClass),
+            slots: nodes
+        }) : Object.entries(nodes).map(([name, node])=>/*#__PURE__*/ jsxRuntime.jsx("div", {
+                children: node
+            }, name))
+    });
+}
+/** The components the preview host and the Stage add to the registry for composed screens. */ const previewComponents = {
+    [previewTemplateComponent]: PreviewTemplate
+};
+
+exports.PreviewTemplate = PreviewTemplate;
+exports.previewComponents = previewComponents;
+exports.previewTemplateComponent = previewTemplateComponent;
+//# sourceMappingURL=PreviewTemplate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewTemplate.js","sources":["../../../preview-host/PreviewTemplate.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 { ReactNode } from 'react';\nimport type { FlowArrangement } from '@cratis/scene.model';\nimport { evaluateFlowArrangement } from '@cratis/scene.engine';\nimport type { ComponentRegistry, RegisteredComponentProps } from '@cratis/scene.react';\nimport { FlowArrangementView } from './FlowArrangementView';\nimport { useSizeClass } from './useSizeClass';\n\n/** The name the template wrapper is registered under. */\nexport const previewTemplateComponent = 'Scene:template';\n\nfunction isFlowArrangement(arrangement: unknown): arrangement is FlowArrangement {\n    return !!arrangement && typeof arrangement === 'object' && 'root' in arrangement;\n}\n\n/**\n * A screen's content inside the screen template it names.\n *\n * The template's own `arrangement flow` positions its slots - header, body, aside - exactly as the document wrote it, evaluated\n * for the window's current size class. A template with no flow arrangement stacks them. It sits inside the shell's content\n * slot, so the shell, not this, owns the chrome around it. Stage and the preview host render templates with this one component.\n */\nexport function PreviewTemplate({ element, slots }: RegisteredComponentProps) {\n    const sizeClass = useSizeClass();\n    const arrangement = (element.properties as Record<string, unknown> | undefined)?.arrangement;\n    const nodes: Record<string, ReactNode> = {};\n    for (const [name, content] of Object.entries(slots)) {\n        nodes[name] = <section className='scene-template-slot' data-slot={name}>{content}</section>;\n    }\n\n    return (\n        <div className='scene-template' data-scene-id={element.id}>\n            {isFlowArrangement(arrangement)\n                ? <FlowArrangementView node={evaluateFlowArrangement(arrangement, sizeClass)} slots={nodes} />\n                : Object.entries(nodes).map(([name, node]) => <div key={name}>{node}</div>)}\n        </div>\n    );\n}\n\n/** The components the preview host and the Stage add to the registry for composed screens. */\nexport const previewComponents: ComponentRegistry = {\n    [previewTemplateComponent]: PreviewTemplate,\n};\n"],"names":["previewTemplateComponent","isFlowArrangement","arrangement","PreviewTemplate","element","slots","sizeClass","useSizeClass","properties","nodes","name","content","Object","entries","_jsx","section","className","data-slot","div","data-scene-id","id","FlowArrangementView","node","evaluateFlowArrangement","map","previewComponents"],"mappings":";;;;;;;AAAA;AACA;AASA,0DACO,MAAMA,wBAAAA,GAA2B;AAExC,SAASC,kBAAkBC,WAAoB,EAAA;AAC3C,IAAA,OAAO,CAAC,CAACA,WAAAA,IAAe,OAAOA,WAAAA,KAAgB,YAAY,MAAA,IAAUA,WAAAA;AACzE;AAEA;;;;;;AAMC,IACM,SAASC,eAAAA,CAAgB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACxE,IAAA,MAAMC,SAAAA,GAAYC,yBAAAA,EAAAA;IAClB,MAAML,WAAAA,GAAeE,OAAAA,CAAQI,UAAU,EAA0CN,WAAAA;AACjF,IAAA,MAAMO,QAAmC,EAAC;IAC1C,KAAK,MAAM,CAACC,IAAAA,EAAMC,OAAAA,CAAQ,IAAIC,MAAAA,CAAOC,OAAO,CAACR,KAAAA,CAAAA,CAAQ;QACjDI,KAAK,CAACC,IAAAA,CAAK,iBAAGI,cAAA,CAACC,SAAAA,EAAAA;YAAQC,SAAAA,EAAU,qBAAA;YAAsBC,WAAAA,EAAWP,IAAAA;AAAOC,YAAAA,QAAAA,EAAAA;;AAC7E,IAAA;AAEA,IAAA,qBACIG,cAAA,CAACI,KAAAA,EAAAA;QAAIF,SAAAA,EAAU,gBAAA;AAAiBG,QAAAA,eAAAA,EAAef,QAAQgB,EAAE;AACpDnB,QAAAA,QAAAA,EAAAA,iBAAAA,CAAkBC,6BACbY,cAAA,CAACO,uCAAAA,EAAAA;AAAoBC,YAAAA,IAAAA,EAAMC,qCAAwBrB,WAAAA,EAAaI,SAAAA,CAAAA;YAAYD,KAAAA,EAAOI;aACnFG,MAAAA,CAAOC,OAAO,CAACJ,KAAAA,CAAAA,CAAOe,GAAG,CAAC,CAAC,CAACd,IAAAA,EAAMY,IAAAA,CAAK,iBAAKR,cAAA,CAACI,KAAAA,EAAAA;AAAgBI,gBAAAA,QAAAA,EAAAA;AAAPZ,aAAAA,EAAAA,IAAAA,CAAAA;;AAGxE;AAEA,+FACO,MAAMe,iBAAAA,GAAuC;AAChD,IAAA,CAACzB,2BAA2BG;AAChC;;;;"}