@cratis/scene.engine 0.1.0

package/BindingResolver.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { BindingExpression } from '@cratis/scene.model';
+
+/**
+ * Resolves a {@link BindingExpression} to its current value. How a binding is actually resolved -
+ * against a Stage-produced data context, a Studio design-time fixture, or anything else - is owned by
+ * whoever drives the engine, not by the engine itself.
+ */
+export type BindingResolver = (binding: BindingExpression) => unknown;

package/ComponentResolution.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * The outcome of resolving a bare or package-qualified component name against a {@link UiProfile}'s
+ * package list.
+ */
+export interface ComponentResolution {
+    /** The bare component name within {@link package}. */
+    name: string;
+
+    /** The package the name resolved to. */
+    package: string;
+
+    /**
+     * Other active packages, in descending priority order, that also declare this name but were
+     * shadowed by {@link package} - this is what answers "why did this resolve to X and not Y". Always
+     * empty for a package-qualified reference, which resolves directly against its named package and
+     * never runs shadow tracking.
+     */
+    shadows: string[];
+}

package/PackageSelection.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * A dependency a selected package declares that nothing in the catalog can satisfy — so it cannot be
+ * pulled in automatically, and the selection is genuinely incomplete rather than merely under-specified.
+ */
+export interface MissingPackageDependency {
+    /**
+     * The package that declares the dependency.
+     */
+    package: string;
+
+    /**
+     * The name of the package it depends on, which the catalog does not contain.
+     */
+    dependsOn: string;
+}
+
+/**
+ * A dependency that resolved to a package the catalog does contain, but at a version its declared range
+ * does not accept.
+ */
+export interface PackageVersionConflict {
+    /**
+     * The package that declares the dependency.
+     */
+    package: string;
+
+    /**
+     * The name of the package it depends on.
+     */
+    dependsOn: string;
+
+    /**
+     * The range the declaring package asked for.
+     */
+    requiredRange: string;
+
+    /**
+     * The version the catalog actually offers.
+     */
+    actualVersion: string;
+}
+
+/**
+ * The outcome of expanding a chosen set of package names into the full set a {@link UiProfile} actually
+ * needs.
+ */
+export interface PackageSelection {
+    /**
+     * Every package the selection requires, in ascending override-priority order: a package always
+     * appears after the packages it depends on, so a package that layers on top of another shadows it on
+     * a name collision. That is the order a profile's `packages` list should carry.
+     */
+    packages: string[];
+
+    /**
+     * The packages pulled in transitively that the caller did not choose — what a package picker tells
+     * the user it is about to add on their behalf.
+     */
+    added: string[];
+
+    /**
+     * Dependencies nothing in the catalog can satisfy.
+     */
+    missing: MissingPackageDependency[];
+
+    /**
+     * Dependencies satisfied by name but not by version.
+     */
+    versionConflicts: PackageVersionConflict[];
+
+    /**
+     * Dependency cycles found while ordering, each listed as the packages involved. A cycle has no valid
+     * priority order, so its members are emitted in discovery order and reported here rather than
+     * silently arranged into one.
+     */
+    cycles: string[][];
+}
+
+/**
+ * Whether a selection is complete and orderable — nothing missing, no version conflict, no cycle.
+ */
+export function isPackageSelectionValid(selection: PackageSelection): boolean {
+    return selection.missing.length === 0 && selection.versionConflicts.length === 0 && selection.cycles.length === 0;
+}

package/README.md

@@ -0,0 +1,40 @@
+# Scene
+
+The object model and runtime for Screenplay-based UIs: `Scene.Model` (platform-agnostic screens, layouts,
+forms, contribution points, ui profiles and themes), `Scene.Engine` (binding/resolution runtime), and
+`Scene.React` (the React renderer).
+
+## Packages / Deployables
+
+[![Nuget](https://img.shields.io/nuget/v/Cratis.Scene.Model?logo=nuget)](http://nuget.org/packages/Cratis.Scene.Model)
+[![NPM](https://img.shields.io/npm/v/@cratis/scene.model?label=@cratis/scene.model&logo=npm)](https://www.npmjs.com/package/@cratis/scene.model)
+[![NPM](https://img.shields.io/npm/v/@cratis/scene.engine?label=@cratis/scene.engine&logo=npm)](https://www.npmjs.com/package/@cratis/scene.engine)
+[![NPM](https://img.shields.io/npm/v/@cratis/scene.react?label=@cratis/scene.react&logo=npm)](https://www.npmjs.com/package/@cratis/scene.react)
+
+## Builds
+
+[![.NET Build](https://github.com/cratis/scene/actions/workflows/dotnet-build.yml/badge.svg)](https://github.com/cratis/scene/actions/workflows/dotnet-build.yml)
+[![JavaScript Build](https://github.com/cratis/scene/actions/workflows/javascript-build.yml/badge.svg)](https://github.com/cratis/scene/actions/workflows/javascript-build.yml)
+
+## Description
+
+Scene owns the *object model and runtime* half of the Screenplay stack. `Scene.Model` is the platform-agnostic
+C# object model that Stage translates Screenplay's parsed language constructs into, and that Studio's
+design-time tooling reads and writes. `Scene.Engine` walks that graph, resolves bindings (data, action, form,
+navigation contribution) and drives whichever renderer is plugged in — it does not know React exists.
+`Scene.React` is one renderer implementing the abstract vocabulary against real React/DOM; sibling positions
+are reserved for future `Scene.Native` / `Scene.Desktop` renderers. Vendor and internal component packages
+(PrimeReact, internal widget libraries) are adapters plugging into the renderer contract, not part of it.
+
+The design-time editor built on top of this object model lives in Studio, not here — see
+[StudioIssues#156](https://github.com/Cratis/StudioIssues/issues/156).
+
+## Support
+
+Cratis is an open community, and we are glad to help users, teams evaluating the stack, and contributors.
+
+| Channel | Details |
+|---|---|
+| Discord | Join the community on [Discord](https://discord.gg/kt4AMpV8WV) for questions and discussions |
+| GitHub Issues | [Report bugs or request features](https://github.com/Cratis/Scene/issues) |
+| Documentation | Read the docs at [cratis.io](https://cratis.io) |

package/Renderer.ts

@@ -0,0 +1,33 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ContentControl, ItemsControl, ExternalComponent, Panel } from '@cratis/scene.model';
+
+/**
+ * The contract a renderer implements to turn a resolved Scene element tree into `TOutput` - real
+ * React/DOM output for `Scene.React`, and whatever a future `Scene.Native` or `Scene.Desktop` renderer's
+ * own platform needs. One method per concrete element kind Scene.Model ships; an adapter package's own
+ * component types render through {@link renderExternalComponent} rather than needing their own method
+ * here, so this contract does not grow as vendor/internal widget libraries are added.
+ */
+export interface Renderer<TOutput> {
+    /**
+     * Renders a {@link ContentControl}, given its already-rendered content.
+     */
+    renderContentControl(element: ContentControl, content: TOutput): TOutput;
+
+    /**
+     * Renders an {@link ItemsControl}, given its already-rendered items.
+     */
+    renderItemsControl(element: ItemsControl, items: TOutput[]): TOutput;
+
+    /**
+     * Renders an {@link ExternalComponent}, given its already-rendered named slots.
+     */
+    renderExternalComponent(element: ExternalComponent, slots: Record<string, TOutput[]>): TOutput;
+
+    /**
+     * Renders a {@link Panel}, given its already-rendered children.
+     */
+    renderPanel(element: Panel, children: TOutput[]): TOutput;
+}

package/aggregateContributions.ts

@@ -0,0 +1,40 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Contribution } from '@cratis/scene.model';
+
+/**
+ * Aggregates every {@link Contribution} targeting a given contribution point, in render order - part of
+ * Cratis/Scene#2. A widget bound to a contribution point is never wired to a fixed source: call this
+ * again whenever the underlying contribution set changes and it recomputes, the same way a projection
+ * recomputes a read model from events.
+ *
+ * Resolving *which* contribution point a `contribute to` declaration targets (nearest enclosing, or an
+ * explicit override) already happened before a {@link Contribution} exists in this model - see its own
+ * doc comment - so there is no ambiguity left to resolve here, only ordering.
+ *
+ * @param contributions Every contribution in scope, targeting any contribution point.
+ * @param contributionPointName The name of the contribution point to aggregate.
+ * @returns The matching contributions, ordered by `order` ascending; contributions with no `order` sort after every ordered one, in their original relative order.
+ */
+export function aggregateContributions(contributions: Contribution[], contributionPointName: string): Contribution[] {
+    return contributions
+        .map((contribution, index) => ({ contribution, index }))
+        .filter(({ contribution }) => contribution.contributionPointName === contributionPointName)
+        .sort((a, b) => {
+            if (a.contribution.order === undefined && b.contribution.order === undefined) {
+                return a.index - b.index;
+            }
+
+            if (a.contribution.order === undefined) {
+                return 1;
+            }
+
+            if (b.contribution.order === undefined) {
+                return -1;
+            }
+
+            return a.contribution.order - b.contribution.order;
+        })
+        .map(({ contribution }) => contribution);
+}

package/buildStarterProfile.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { SizeClass, UiProfile, UiStarter } from '@cratis/scene.model';
+
+/**
+ * Builds the sandboxed {@link UiProfile} a {@link UiStarter}'s gallery boots through - part of
+ * Cratis/Scene#6. Studio runs a starter's gallery screens as a working mini-app rather than a simulated
+ * preview, so the gallery needs a real profile scoped to exactly the starter's own package list, not the
+ * consuming project's eventual profile. Studio's design-time tooling and Stage's build-time resolution
+ * use the C# twin of this function in `Cratis.Scene.Engine`; both sides are asserted against the same
+ * shared fixture corpus so they cannot drift apart.
+ *
+ * @param starter The {@link UiStarter} to build the profile for.
+ * @param targetPlatform The platform the gallery runs on (e.g. `web`).
+ * @param defaultSizeClass The size class assumed when the renderer cannot otherwise determine one.
+ * @returns A {@link UiProfile} named after the starter, scoped to exactly its own `packages`.
+ */
+export function buildStarterProfile(starter: UiStarter, targetPlatform: string, defaultSizeClass?: SizeClass): UiProfile {
+    return { name: starter.name, targetPlatform, packages: starter.packages, defaultSizeClass };
+}

package/computeSizeClass.ts

@@ -0,0 +1,30 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { HeightSizeClass, SizeClass, WidthSizeClass } from '@cratis/scene.model';
+
+/** The default width, in device-independent pixels, at or above which {@link WidthSizeClass.Regular} applies. */
+export const defaultWidthBreakpoint = 600;
+
+/** The default height, in device-independent pixels, at or above which {@link HeightSizeClass.Regular} applies. */
+export const defaultHeightBreakpoint = 600;
+
+/**
+ * Computes the current {@link SizeClass} from actual available dimensions - shared by every renderer
+ * (`Scene.React`, any future native renderer, Studio's preview surface) so they all agree on when a class
+ * boundary is crossed. Reactive (recompute on resize) vs. fixed-per-launch (mobile, where orientation
+ * change is the only runtime variable) are both just "call this again when the dimensions you have
+ * available change" - the shape is the same either way, only the caller's triggering mechanism differs.
+ *
+ * @param width The available width, in device-independent pixels.
+ * @param height The available height, in device-independent pixels.
+ * @param widthBreakpoint The width at or above which {@link WidthSizeClass.Regular} applies. Defaults to {@link defaultWidthBreakpoint}.
+ * @param heightBreakpoint The height at or above which {@link HeightSizeClass.Regular} applies. Defaults to {@link defaultHeightBreakpoint}.
+ * @returns The computed {@link SizeClass}.
+ */
+export function computeSizeClass(width: number, height: number, widthBreakpoint = defaultWidthBreakpoint, heightBreakpoint = defaultHeightBreakpoint): SizeClass {
+    return {
+        width: width >= widthBreakpoint ? WidthSizeClass.Regular : WidthSizeClass.Compact,
+        height: height >= heightBreakpoint ? HeightSizeClass.Regular : HeightSizeClass.Compact,
+    };
+}

package/dist/cjs/PackageSelection.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * A dependency a selected package declares that nothing in the catalog can satisfy — so it cannot be
+ * pulled in automatically, and the selection is genuinely incomplete rather than merely under-specified.
+ */ /**
+ * Whether a selection is complete and orderable — nothing missing, no version conflict, no cycle.
+ */ function isPackageSelectionValid(selection) {
+    return selection.missing.length === 0 && selection.versionConflicts.length === 0 && selection.cycles.length === 0;
+}
+
+exports.isPackageSelectionValid = isPackageSelectionValid;
+//# sourceMappingURL=PackageSelection.js.map

package/dist/cjs/PackageSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PackageSelection.js","sources":["../../PackageSelection.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 * A dependency a selected package declares that nothing in the catalog can satisfy — so it cannot be\n * pulled in automatically, and the selection is genuinely incomplete rather than merely under-specified.\n */\nexport interface MissingPackageDependency {\n    /**\n     * The package that declares the dependency.\n     */\n    package: string;\n\n    /**\n     * The name of the package it depends on, which the catalog does not contain.\n     */\n    dependsOn: string;\n}\n\n/**\n * A dependency that resolved to a package the catalog does contain, but at a version its declared range\n * does not accept.\n */\nexport interface PackageVersionConflict {\n    /**\n     * The package that declares the dependency.\n     */\n    package: string;\n\n    /**\n     * The name of the package it depends on.\n     */\n    dependsOn: string;\n\n    /**\n     * The range the declaring package asked for.\n     */\n    requiredRange: string;\n\n    /**\n     * The version the catalog actually offers.\n     */\n    actualVersion: string;\n}\n\n/**\n * The outcome of expanding a chosen set of package names into the full set a {@link UiProfile} actually\n * needs.\n */\nexport interface PackageSelection {\n    /**\n     * Every package the selection requires, in ascending override-priority order: a package always\n     * appears after the packages it depends on, so a package that layers on top of another shadows it on\n     * a name collision. That is the order a profile's `packages` list should carry.\n     */\n    packages: string[];\n\n    /**\n     * The packages pulled in transitively that the caller did not choose — what a package picker tells\n     * the user it is about to add on their behalf.\n     */\n    added: string[];\n\n    /**\n     * Dependencies nothing in the catalog can satisfy.\n     */\n    missing: MissingPackageDependency[];\n\n    /**\n     * Dependencies satisfied by name but not by version.\n     */\n    versionConflicts: PackageVersionConflict[];\n\n    /**\n     * Dependency cycles found while ordering, each listed as the packages involved. A cycle has no valid\n     * priority order, so its members are emitted in discovery order and reported here rather than\n     * silently arranged into one.\n     */\n    cycles: string[][];\n}\n\n/**\n * Whether a selection is complete and orderable — nothing missing, no version conflict, no cycle.\n */\nexport function isPackageSelectionValid(selection: PackageSelection): boolean {\n    return selection.missing.length === 0 && selection.versionConflicts.length === 0 && selection.cycles.length === 0;\n}\n"],"names":["isPackageSelectionValid","selection","missing","length","versionConflicts","cycles"],"mappings":";;AAAA;AACA;AAEA;;;;;IAiFO,SAASA,uBAAAA,CAAwBC,SAA2B,EAAA;AAC/D,IAAA,OAAOA,UAAUC,OAAO,CAACC,MAAM,KAAK,KAAKF,SAAAA,CAAUG,gBAAgB,CAACD,MAAM,KAAK,CAAA,IAAKF,SAAAA,CAAUI,MAAM,CAACF,MAAM,KAAK,CAAA;AACpH;;;;"}

package/dist/cjs/aggregateContributions.js

@@ -0,0 +1,37 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Aggregates every {@link Contribution} targeting a given contribution point, in render order - part of
+ * Cratis/Scene#2. A widget bound to a contribution point is never wired to a fixed source: call this
+ * again whenever the underlying contribution set changes and it recomputes, the same way a projection
+ * recomputes a read model from events.
+ *
+ * Resolving *which* contribution point a `contribute to` declaration targets (nearest enclosing, or an
+ * explicit override) already happened before a {@link Contribution} exists in this model - see its own
+ * doc comment - so there is no ambiguity left to resolve here, only ordering.
+ *
+ * @param contributions Every contribution in scope, targeting any contribution point.
+ * @param contributionPointName The name of the contribution point to aggregate.
+ * @returns The matching contributions, ordered by `order` ascending; contributions with no `order` sort after every ordered one, in their original relative order.
+ */ function aggregateContributions(contributions, contributionPointName) {
+    return contributions.map((contribution, index)=>({
+            contribution,
+            index
+        })).filter(({ contribution })=>contribution.contributionPointName === contributionPointName).sort((a, b)=>{
+        if (a.contribution.order === undefined && b.contribution.order === undefined) {
+            return a.index - b.index;
+        }
+        if (a.contribution.order === undefined) {
+            return 1;
+        }
+        if (b.contribution.order === undefined) {
+            return -1;
+        }
+        return a.contribution.order - b.contribution.order;
+    }).map(({ contribution })=>contribution);
+}
+
+exports.aggregateContributions = aggregateContributions;
+//# sourceMappingURL=aggregateContributions.js.map

package/dist/cjs/aggregateContributions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateContributions.js","sources":["../../aggregateContributions.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 { Contribution } from '@cratis/scene.model';\n\n/**\n * Aggregates every {@link Contribution} targeting a given contribution point, in render order - part of\n * Cratis/Scene#2. A widget bound to a contribution point is never wired to a fixed source: call this\n * again whenever the underlying contribution set changes and it recomputes, the same way a projection\n * recomputes a read model from events.\n *\n * Resolving *which* contribution point a `contribute to` declaration targets (nearest enclosing, or an\n * explicit override) already happened before a {@link Contribution} exists in this model - see its own\n * doc comment - so there is no ambiguity left to resolve here, only ordering.\n *\n * @param contributions Every contribution in scope, targeting any contribution point.\n * @param contributionPointName The name of the contribution point to aggregate.\n * @returns The matching contributions, ordered by `order` ascending; contributions with no `order` sort after every ordered one, in their original relative order.\n */\nexport function aggregateContributions(contributions: Contribution[], contributionPointName: string): Contribution[] {\n    return contributions\n        .map((contribution, index) => ({ contribution, index }))\n        .filter(({ contribution }) => contribution.contributionPointName === contributionPointName)\n        .sort((a, b) => {\n            if (a.contribution.order === undefined && b.contribution.order === undefined) {\n                return a.index - b.index;\n            }\n\n            if (a.contribution.order === undefined) {\n                return 1;\n            }\n\n            if (b.contribution.order === undefined) {\n                return -1;\n            }\n\n            return a.contribution.order - b.contribution.order;\n        })\n        .map(({ contribution }) => contribution);\n}\n"],"names":["aggregateContributions","contributions","contributionPointName","map","contribution","index","filter","sort","a","b","order","undefined"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;;;;;;AAaC,IACM,SAASA,sBAAAA,CAAuBC,aAA6B,EAAEC,qBAA6B,EAAA;AAC/F,IAAA,OAAOD,cACFE,GAAG,CAAC,CAACC,YAAAA,EAAcC,SAAW;AAAED,YAAAA,YAAAA;AAAcC,YAAAA;AAAM,SAAA,CAAA,CAAA,CACpDC,MAAM,CAAC,CAAC,EAAEF,YAAY,EAAE,GAAKA,YAAAA,CAAaF,qBAAqB,KAAKA,qBAAAA,CAAAA,CACpEK,IAAI,CAAC,CAACC,CAAAA,EAAGC,CAAAA,GAAAA;QACN,IAAID,CAAAA,CAAEJ,YAAY,CAACM,KAAK,KAAKC,SAAAA,IAAaF,CAAAA,CAAEL,YAAY,CAACM,KAAK,KAAKC,SAAAA,EAAW;AAC1E,YAAA,OAAOH,CAAAA,CAAEH,KAAK,GAAGI,CAAAA,CAAEJ,KAAK;AAC5B,QAAA;AAEA,QAAA,IAAIG,CAAAA,CAAEJ,YAAY,CAACM,KAAK,KAAKC,SAAAA,EAAW;YACpC,OAAO,CAAA;AACX,QAAA;AAEA,QAAA,IAAIF,CAAAA,CAAEL,YAAY,CAACM,KAAK,KAAKC,SAAAA,EAAW;AACpC,YAAA,OAAO,EAAC;AACZ,QAAA;QAEA,OAAOH,CAAAA,CAAEJ,YAAY,CAACM,KAAK,GAAGD,CAAAA,CAAEL,YAAY,CAACM,KAAK;AACtD,IAAA,CAAA,CAAA,CACCP,GAAG,CAAC,CAAC,EAAEC,YAAY,EAAE,GAAKA,YAAAA,CAAAA;AACnC;;;;"}

package/dist/cjs/buildStarterProfile.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Builds the sandboxed {@link UiProfile} a {@link UiStarter}'s gallery boots through - part of
+ * Cratis/Scene#6. Studio runs a starter's gallery screens as a working mini-app rather than a simulated
+ * preview, so the gallery needs a real profile scoped to exactly the starter's own package list, not the
+ * consuming project's eventual profile. Studio's design-time tooling and Stage's build-time resolution
+ * use the C# twin of this function in `Cratis.Scene.Engine`; both sides are asserted against the same
+ * shared fixture corpus so they cannot drift apart.
+ *
+ * @param starter The {@link UiStarter} to build the profile for.
+ * @param targetPlatform The platform the gallery runs on (e.g. `web`).
+ * @param defaultSizeClass The size class assumed when the renderer cannot otherwise determine one.
+ * @returns A {@link UiProfile} named after the starter, scoped to exactly its own `packages`.
+ */ function buildStarterProfile(starter, targetPlatform, defaultSizeClass) {
+    return {
+        name: starter.name,
+        targetPlatform,
+        packages: starter.packages,
+        defaultSizeClass
+    };
+}
+
+exports.buildStarterProfile = buildStarterProfile;
+//# sourceMappingURL=buildStarterProfile.js.map

package/dist/cjs/buildStarterProfile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildStarterProfile.js","sources":["../../buildStarterProfile.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 { SizeClass, UiProfile, UiStarter } from '@cratis/scene.model';\n\n/**\n * Builds the sandboxed {@link UiProfile} a {@link UiStarter}'s gallery boots through - part of\n * Cratis/Scene#6. Studio runs a starter's gallery screens as a working mini-app rather than a simulated\n * preview, so the gallery needs a real profile scoped to exactly the starter's own package list, not the\n * consuming project's eventual profile. Studio's design-time tooling and Stage's build-time resolution\n * use the C# twin of this function in `Cratis.Scene.Engine`; both sides are asserted against the same\n * shared fixture corpus so they cannot drift apart.\n *\n * @param starter The {@link UiStarter} to build the profile for.\n * @param targetPlatform The platform the gallery runs on (e.g. `web`).\n * @param defaultSizeClass The size class assumed when the renderer cannot otherwise determine one.\n * @returns A {@link UiProfile} named after the starter, scoped to exactly its own `packages`.\n */\nexport function buildStarterProfile(starter: UiStarter, targetPlatform: string, defaultSizeClass?: SizeClass): UiProfile {\n    return { name: starter.name, targetPlatform, packages: starter.packages, defaultSizeClass };\n}\n"],"names":["buildStarterProfile","starter","targetPlatform","defaultSizeClass","name","packages"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;;;;;AAYC,IACM,SAASA,mBAAAA,CAAoBC,OAAkB,EAAEC,cAAsB,EAAEC,gBAA4B,EAAA;IACxG,OAAO;AAAEC,QAAAA,IAAAA,EAAMH,QAAQG,IAAI;AAAEF,QAAAA,cAAAA;AAAgBG,QAAAA,QAAAA,EAAUJ,QAAQI,QAAQ;AAAEF,QAAAA;AAAiB,KAAA;AAC9F;;;;"}

package/dist/cjs/computeSizeClass.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var scene_model = require('@cratis/scene.model');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The default width, in device-independent pixels, at or above which {@link WidthSizeClass.Regular} applies. */ const defaultWidthBreakpoint = 600;
+/** The default height, in device-independent pixels, at or above which {@link HeightSizeClass.Regular} applies. */ const defaultHeightBreakpoint = 600;
+/**
+ * Computes the current {@link SizeClass} from actual available dimensions - shared by every renderer
+ * (`Scene.React`, any future native renderer, Studio's preview surface) so they all agree on when a class
+ * boundary is crossed. Reactive (recompute on resize) vs. fixed-per-launch (mobile, where orientation
+ * change is the only runtime variable) are both just "call this again when the dimensions you have
+ * available change" - the shape is the same either way, only the caller's triggering mechanism differs.
+ *
+ * @param width The available width, in device-independent pixels.
+ * @param height The available height, in device-independent pixels.
+ * @param widthBreakpoint The width at or above which {@link WidthSizeClass.Regular} applies. Defaults to {@link defaultWidthBreakpoint}.
+ * @param heightBreakpoint The height at or above which {@link HeightSizeClass.Regular} applies. Defaults to {@link defaultHeightBreakpoint}.
+ * @returns The computed {@link SizeClass}.
+ */ function computeSizeClass(width, height, widthBreakpoint = defaultWidthBreakpoint, heightBreakpoint = defaultHeightBreakpoint) {
+    return {
+        width: width >= widthBreakpoint ? scene_model.WidthSizeClass.Regular : scene_model.WidthSizeClass.Compact,
+        height: height >= heightBreakpoint ? scene_model.HeightSizeClass.Regular : scene_model.HeightSizeClass.Compact
+    };
+}
+
+exports.computeSizeClass = computeSizeClass;
+exports.defaultHeightBreakpoint = defaultHeightBreakpoint;
+exports.defaultWidthBreakpoint = defaultWidthBreakpoint;
+//# sourceMappingURL=computeSizeClass.js.map

package/dist/cjs/computeSizeClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeSizeClass.js","sources":["../../computeSizeClass.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 { HeightSizeClass, SizeClass, WidthSizeClass } from '@cratis/scene.model';\n\n/** The default width, in device-independent pixels, at or above which {@link WidthSizeClass.Regular} applies. */\nexport const defaultWidthBreakpoint = 600;\n\n/** The default height, in device-independent pixels, at or above which {@link HeightSizeClass.Regular} applies. */\nexport const defaultHeightBreakpoint = 600;\n\n/**\n * Computes the current {@link SizeClass} from actual available dimensions - shared by every renderer\n * (`Scene.React`, any future native renderer, Studio's preview surface) so they all agree on when a class\n * boundary is crossed. Reactive (recompute on resize) vs. fixed-per-launch (mobile, where orientation\n * change is the only runtime variable) are both just \"call this again when the dimensions you have\n * available change\" - the shape is the same either way, only the caller's triggering mechanism differs.\n *\n * @param width The available width, in device-independent pixels.\n * @param height The available height, in device-independent pixels.\n * @param widthBreakpoint The width at or above which {@link WidthSizeClass.Regular} applies. Defaults to {@link defaultWidthBreakpoint}.\n * @param heightBreakpoint The height at or above which {@link HeightSizeClass.Regular} applies. Defaults to {@link defaultHeightBreakpoint}.\n * @returns The computed {@link SizeClass}.\n */\nexport function computeSizeClass(width: number, height: number, widthBreakpoint = defaultWidthBreakpoint, heightBreakpoint = defaultHeightBreakpoint): SizeClass {\n    return {\n        width: width >= widthBreakpoint ? WidthSizeClass.Regular : WidthSizeClass.Compact,\n        height: height >= heightBreakpoint ? HeightSizeClass.Regular : HeightSizeClass.Compact,\n    };\n}\n"],"names":["defaultWidthBreakpoint","defaultHeightBreakpoint","computeSizeClass","width","height","widthBreakpoint","heightBreakpoint","WidthSizeClass","Regular","Compact","HeightSizeClass"],"mappings":";;;;AAAA;AACA;AAIA,kHACO,MAAMA,sBAAAA,GAAyB;AAEtC,oHACO,MAAMC,uBAAAA,GAA0B;AAEvC;;;;;;;;;;;;IAaO,SAASC,gBAAAA,CAAiBC,KAAa,EAAEC,MAAc,EAAEC,eAAAA,GAAkBL,sBAAsB,EAAEM,gBAAAA,GAAmBL,uBAAuB,EAAA;IAChJ,OAAO;AACHE,QAAAA,KAAAA,EAAOA,SAASE,eAAAA,GAAkBE,0BAAAA,CAAeC,OAAO,GAAGD,2BAAeE,OAAO;AACjFL,QAAAA,MAAAA,EAAQA,UAAUE,gBAAAA,GAAmBI,2BAAAA,CAAgBF,OAAO,GAAGE,4BAAgBD;AACnF,KAAA;AACJ;;;;;;"}

package/dist/cjs/elementKind.js

@@ -0,0 +1,26 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Type guards distinguishing the concrete element kinds Scene.Model ships, by the property each kind
+ * alone declares. A tree produced by Stage or Studio only ever carries these concrete shapes - `Element`,
+ * `VisualElement`, `FrameworkElement` and `Control` are never instantiated directly.
+ */ function isContentControl(element) {
+    return 'content' in element;
+}
+function isItemsControl(element) {
+    return 'itemsSource' in element && 'itemTemplate' in element;
+}
+function isExternalComponent(element) {
+    return 'componentName' in element;
+}
+function isPanel(element) {
+    return 'children' in element;
+}
+
+exports.isContentControl = isContentControl;
+exports.isExternalComponent = isExternalComponent;
+exports.isItemsControl = isItemsControl;
+exports.isPanel = isPanel;
+//# sourceMappingURL=elementKind.js.map

package/dist/cjs/elementKind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementKind.js","sources":["../../elementKind.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 { SceneElement, ContentControl, ItemsControl, ExternalComponent, Panel } from '@cratis/scene.model';\n\n/**\n * Type guards distinguishing the concrete element kinds Scene.Model ships, by the property each kind\n * alone declares. A tree produced by Stage or Studio only ever carries these concrete shapes - `Element`,\n * `VisualElement`, `FrameworkElement` and `Control` are never instantiated directly.\n */\n\nexport function isContentControl(element: SceneElement): element is ContentControl {\n    return 'content' in element;\n}\n\nexport function isItemsControl(element: SceneElement): element is ItemsControl {\n    return 'itemsSource' in element && 'itemTemplate' in element;\n}\n\nexport function isExternalComponent(element: SceneElement): element is ExternalComponent {\n    return 'componentName' in element;\n}\n\nexport function isPanel(element: SceneElement): element is Panel {\n    return 'children' in element;\n}\n"],"names":["isContentControl","element","isItemsControl","isExternalComponent","isPanel"],"mappings":";;AAAA;AACA;AAIA;;;;IAMO,SAASA,gBAAAA,CAAiBC,OAAqB,EAAA;AAClD,IAAA,OAAO,SAAA,IAAaA,OAAAA;AACxB;AAEO,SAASC,eAAeD,OAAqB,EAAA;IAChD,OAAO,aAAA,IAAiBA,WAAW,cAAA,IAAkBA,OAAAA;AACzD;AAEO,SAASE,oBAAoBF,OAAqB,EAAA;AACrD,IAAA,OAAO,eAAA,IAAmBA,OAAAA;AAC9B;AAEO,SAASG,QAAQH,OAAqB,EAAA;AACzC,IAAA,OAAO,UAAA,IAAcA,OAAAA;AACzB;;;;;;;"}

package/dist/cjs/evaluateFlowArrangement.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Selects the {@link FlowNode} tree that applies for a given {@link SizeClass} - part of Cratis/Scene#4.
+ *
+ * @param arrangement The {@link FlowArrangement} to evaluate.
+ * @param sizeClass The current {@link SizeClass}.
+ * @returns The most specific matching override's root (both dimensions targeted beats one; the last declared wins among equally specific matches), or `arrangement.root` when no override matches.
+ */ function evaluateFlowArrangement(arrangement, sizeClass) {
+    let best;
+    for (const candidate of arrangement.overrides ?? []){
+        if (!matches(candidate, sizeClass)) {
+            continue;
+        }
+        if (!best || specificity(candidate) >= specificity(best)) {
+            best = candidate;
+        }
+    }
+    return best?.root ?? arrangement.root;
+}
+function matches(override, sizeClass) {
+    return (override.width === undefined || override.width === sizeClass.width) && (override.height === undefined || override.height === sizeClass.height);
+}
+function specificity(override) {
+    return (override.width !== undefined ? 1 : 0) + (override.height !== undefined ? 1 : 0);
+}
+
+exports.evaluateFlowArrangement = evaluateFlowArrangement;
+//# sourceMappingURL=evaluateFlowArrangement.js.map

package/dist/cjs/evaluateFlowArrangement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateFlowArrangement.js","sources":["../../evaluateFlowArrangement.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 { FlowArrangement, FlowNode, FlowOverride, SizeClass } from '@cratis/scene.model';\n\n/**\n * Selects the {@link FlowNode} tree that applies for a given {@link SizeClass} - part of Cratis/Scene#4.\n *\n * @param arrangement The {@link FlowArrangement} to evaluate.\n * @param sizeClass The current {@link SizeClass}.\n * @returns The most specific matching override's root (both dimensions targeted beats one; the last declared wins among equally specific matches), or `arrangement.root` when no override matches.\n */\nexport function evaluateFlowArrangement(arrangement: FlowArrangement, sizeClass: SizeClass): FlowNode {\n    let best: FlowOverride | undefined;\n    for (const candidate of arrangement.overrides ?? []) {\n        if (!matches(candidate, sizeClass)) {\n            continue;\n        }\n\n        if (!best || specificity(candidate) >= specificity(best)) {\n            best = candidate;\n        }\n    }\n\n    return best?.root ?? arrangement.root;\n}\n\nfunction matches(override: FlowOverride, sizeClass: SizeClass): boolean {\n    return (override.width === undefined || override.width === sizeClass.width) &&\n        (override.height === undefined || override.height === sizeClass.height);\n}\n\nfunction specificity(override: FlowOverride): number {\n    return (override.width !== undefined ? 1 : 0) + (override.height !== undefined ? 1 : 0);\n}\n"],"names":["evaluateFlowArrangement","arrangement","sizeClass","best","candidate","overrides","matches","specificity","root","override","width","undefined","height"],"mappings":";;AAAA;AACA;AAIA;;;;;;AAMC,IACM,SAASA,uBAAAA,CAAwBC,WAA4B,EAAEC,SAAoB,EAAA;IACtF,IAAIC,IAAAA;AACJ,IAAA,KAAK,MAAMC,SAAAA,IAAaH,WAAAA,CAAYI,SAAS,IAAI,EAAE,CAAE;QACjD,IAAI,CAACC,OAAAA,CAAQF,SAAAA,EAAWF,SAAAA,CAAAA,EAAY;AAChC,YAAA;AACJ,QAAA;AAEA,QAAA,IAAI,CAACC,IAAAA,IAAQI,WAAAA,CAAYH,SAAAA,CAAAA,IAAcG,YAAYJ,IAAAA,CAAAA,EAAO;YACtDA,IAAAA,GAAOC,SAAAA;AACX,QAAA;AACJ,IAAA;IAEA,OAAOD,IAAAA,EAAMK,IAAAA,IAAQP,WAAAA,CAAYO,IAAI;AACzC;AAEA,SAASF,OAAAA,CAAQG,QAAsB,EAAEP,SAAoB,EAAA;IACzD,OAAQO,CAAAA,QAAAA,CAASC,KAAK,KAAKC,SAAAA,IAAaF,QAAAA,CAASC,KAAK,KAAKR,SAAAA,CAAUQ,KAAK,MACrED,QAAAA,CAASG,MAAM,KAAKD,SAAAA,IAAaF,SAASG,MAAM,KAAKV,SAAAA,CAAUU,MAAM,CAAD;AAC7E;AAEA,SAASL,YAAYE,QAAsB,EAAA;AACvC,IAAA,OAAO,CAACA,QAAAA,CAASC,KAAK,KAAKC,SAAAA,GAAY,CAAA,GAAI,CAAA,KAAMF,QAAAA,CAASG,MAAM,KAAKD,SAAAA,GAAY,IAAI,CAAA,CAAA;AACzF;;;;"}

package/dist/cjs/evaluateFreeformArrangement.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Selects the {@link FreeformVariant} that targets a given {@link SizeClass} - part of Cratis/Scene#4.
+ *
+ * @param arrangement The {@link FreeformArrangement} to evaluate.
+ * @param sizeClass The current {@link SizeClass}.
+ * @returns The variant whose size class exactly matches, or `undefined` when nothing targets it. There is deliberately no fallback here - a size class with no matching variant is a design-time/build-time warning elsewhere, never a silently picked variant.
+ */ function evaluateFreeformArrangement(arrangement, sizeClass) {
+    return arrangement.variants.find((variant)=>variant.sizeClass.width === sizeClass.width && variant.sizeClass.height === sizeClass.height);
+}
+
+exports.evaluateFreeformArrangement = evaluateFreeformArrangement;
+//# sourceMappingURL=evaluateFreeformArrangement.js.map

package/dist/cjs/evaluateFreeformArrangement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateFreeformArrangement.js","sources":["../../evaluateFreeformArrangement.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 { FreeformArrangement, FreeformVariant, SizeClass } from '@cratis/scene.model';\n\n/**\n * Selects the {@link FreeformVariant} that targets a given {@link SizeClass} - part of Cratis/Scene#4.\n *\n * @param arrangement The {@link FreeformArrangement} to evaluate.\n * @param sizeClass The current {@link SizeClass}.\n * @returns The variant whose size class exactly matches, or `undefined` when nothing targets it. There is deliberately no fallback here - a size class with no matching variant is a design-time/build-time warning elsewhere, never a silently picked variant.\n */\nexport function evaluateFreeformArrangement(arrangement: FreeformArrangement, sizeClass: SizeClass): FreeformVariant | undefined {\n    return arrangement.variants.find(variant => variant.sizeClass.width === sizeClass.width && variant.sizeClass.height === sizeClass.height);\n}\n"],"names":["evaluateFreeformArrangement","arrangement","sizeClass","variants","find","variant","width","height"],"mappings":";;AAAA;AACA;AAIA;;;;;;AAMC,IACM,SAASA,2BAAAA,CAA4BC,WAAgC,EAAEC,SAAoB,EAAA;IAC9F,OAAOD,WAAAA,CAAYE,QAAQ,CAACC,IAAI,CAACC,CAAAA,OAAAA,GAAWA,QAAQH,SAAS,CAACI,KAAK,KAAKJ,SAAAA,CAAUI,KAAK,IAAID,OAAAA,CAAQH,SAAS,CAACK,MAAM,KAAKL,SAAAA,CAAUK,MAAM,CAAA;AAC5I;;;;"}

package/dist/cjs/evaluateFreeformSlotArrangement.js

@@ -0,0 +1,18 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Selects the {@link FreeformSlotVariant} that targets a given {@link SizeClass} - the counterpart to
+ * {@link evaluateFreeformArrangement} for a `Layout`'s own macro `arrangement`, which places the layout's
+ * slots themselves rather than the content of one slot.
+ *
+ * @param arrangement The {@link FreeformSlotArrangement} to evaluate.
+ * @param sizeClass The current {@link SizeClass}.
+ * @returns The variant whose size class exactly matches, or `undefined` when nothing targets it. There is deliberately no fallback here - a size class with no matching variant is a design-time/build-time warning elsewhere, never a silently picked variant.
+ */ function evaluateFreeformSlotArrangement(arrangement, sizeClass) {
+    return arrangement.variants.find((variant)=>variant.sizeClass.width === sizeClass.width && variant.sizeClass.height === sizeClass.height);
+}
+
+exports.evaluateFreeformSlotArrangement = evaluateFreeformSlotArrangement;
+//# sourceMappingURL=evaluateFreeformSlotArrangement.js.map

package/dist/cjs/evaluateFreeformSlotArrangement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateFreeformSlotArrangement.js","sources":["../../evaluateFreeformSlotArrangement.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 { FreeformSlotArrangement, FreeformSlotVariant, SizeClass } from '@cratis/scene.model';\n\n/**\n * Selects the {@link FreeformSlotVariant} that targets a given {@link SizeClass} - the counterpart to\n * {@link evaluateFreeformArrangement} for a `Layout`'s own macro `arrangement`, which places the layout's\n * slots themselves rather than the content of one slot.\n *\n * @param arrangement The {@link FreeformSlotArrangement} to evaluate.\n * @param sizeClass The current {@link SizeClass}.\n * @returns The variant whose size class exactly matches, or `undefined` when nothing targets it. There is deliberately no fallback here - a size class with no matching variant is a design-time/build-time warning elsewhere, never a silently picked variant.\n */\nexport function evaluateFreeformSlotArrangement(arrangement: FreeformSlotArrangement, sizeClass: SizeClass): FreeformSlotVariant | undefined {\n    return arrangement.variants.find(variant => variant.sizeClass.width === sizeClass.width && variant.sizeClass.height === sizeClass.height);\n}\n"],"names":["evaluateFreeformSlotArrangement","arrangement","sizeClass","variants","find","variant","width","height"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;AAQC,IACM,SAASA,+BAAAA,CAAgCC,WAAoC,EAAEC,SAAoB,EAAA;IACtG,OAAOD,WAAAA,CAAYE,QAAQ,CAACC,IAAI,CAACC,CAAAA,OAAAA,GAAWA,QAAQH,SAAS,CAACI,KAAK,KAAKJ,SAAAA,CAAUI,KAAK,IAAID,OAAAA,CAAQH,SAAS,CAACK,MAAM,KAAKL,SAAAA,CAAUK,MAAM,CAAA;AAC5I;;;;"}

package/dist/cjs/flowNodeKind.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var scene_model = require('@cratis/scene.model');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Type guards distinguishing the concrete nodes a flow arrangement tree is built from.
+ *
+ * Leaves are told apart the same way `elementKind` tells element kinds apart - by the property each one
+ * alone declares. Containers cannot be: a row and a column have exactly the same members, so no structural
+ * test can separate them. They carry an explicit {@link FlowContainerKind} instead, which is what makes
+ * them a discriminated union rather than three identical shapes, and what lets a renderer decide between
+ * a horizontal and a vertical arrangement at all.
+ */ function isFlowContainer(node) {
+    return 'kind' in node && 'children' in node;
+}
+function isFlowRow(node) {
+    return isFlowContainer(node) && node.kind === scene_model.FlowContainerKind.Row;
+}
+function isFlowColumn(node) {
+    return isFlowContainer(node) && node.kind === scene_model.FlowContainerKind.Column;
+}
+function isFlowGrid(node) {
+    return isFlowContainer(node) && node.kind === scene_model.FlowContainerKind.Grid;
+}
+function isFlowLeaf(node) {
+    return 'content' in node;
+}
+function isFlowSlotLeaf(node) {
+    return 'slotName' in node;
+}
+
+exports.isFlowColumn = isFlowColumn;
+exports.isFlowContainer = isFlowContainer;
+exports.isFlowGrid = isFlowGrid;
+exports.isFlowLeaf = isFlowLeaf;
+exports.isFlowRow = isFlowRow;
+exports.isFlowSlotLeaf = isFlowSlotLeaf;
+//# sourceMappingURL=flowNodeKind.js.map

package/dist/cjs/flowNodeKind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowNodeKind.js","sources":["../../flowNodeKind.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 { FlowColumn, FlowContainer, FlowContainerKind, FlowGrid, FlowLeaf, FlowNode, FlowRow, FlowSlotLeaf } from '@cratis/scene.model';\n\n/**\n * Type guards distinguishing the concrete nodes a flow arrangement tree is built from.\n *\n * Leaves are told apart the same way `elementKind` tells element kinds apart - by the property each one\n * alone declares. Containers cannot be: a row and a column have exactly the same members, so no structural\n * test can separate them. They carry an explicit {@link FlowContainerKind} instead, which is what makes\n * them a discriminated union rather than three identical shapes, and what lets a renderer decide between\n * a horizontal and a vertical arrangement at all.\n */\n\nexport function isFlowContainer(node: FlowNode): node is FlowContainer {\n    return 'kind' in node && 'children' in node;\n}\n\nexport function isFlowRow(node: FlowNode): node is FlowRow {\n    return isFlowContainer(node) && node.kind === FlowContainerKind.Row;\n}\n\nexport function isFlowColumn(node: FlowNode): node is FlowColumn {\n    return isFlowContainer(node) && node.kind === FlowContainerKind.Column;\n}\n\nexport function isFlowGrid(node: FlowNode): node is FlowGrid {\n    return isFlowContainer(node) && node.kind === FlowContainerKind.Grid;\n}\n\nexport function isFlowLeaf(node: FlowNode): node is FlowLeaf {\n    return 'content' in node;\n}\n\nexport function isFlowSlotLeaf(node: FlowNode): node is FlowSlotLeaf {\n    return 'slotName' in node;\n}\n"],"names":["isFlowContainer","node","isFlowRow","kind","FlowContainerKind","Row","isFlowColumn","Column","isFlowGrid","Grid","isFlowLeaf","isFlowSlotLeaf"],"mappings":";;;;AAAA;AACA;AAIA;;;;;;;;IAUO,SAASA,eAAAA,CAAgBC,IAAc,EAAA;IAC1C,OAAO,MAAA,IAAUA,QAAQ,UAAA,IAAcA,IAAAA;AAC3C;AAEO,SAASC,UAAUD,IAAc,EAAA;AACpC,IAAA,OAAOD,gBAAgBC,IAAAA,CAAAA,IAASA,IAAAA,CAAKE,IAAI,KAAKC,8BAAkBC,GAAG;AACvE;AAEO,SAASC,aAAaL,IAAc,EAAA;AACvC,IAAA,OAAOD,gBAAgBC,IAAAA,CAAAA,IAASA,IAAAA,CAAKE,IAAI,KAAKC,8BAAkBG,MAAM;AAC1E;AAEO,SAASC,WAAWP,IAAc,EAAA;AACrC,IAAA,OAAOD,gBAAgBC,IAAAA,CAAAA,IAASA,IAAAA,CAAKE,IAAI,KAAKC,8BAAkBK,IAAI;AACxE;AAEO,SAASC,WAAWT,IAAc,EAAA;AACrC,IAAA,OAAO,SAAA,IAAaA,IAAAA;AACxB;AAEO,SAASU,eAAeV,IAAc,EAAA;AACzC,IAAA,OAAO,UAAA,IAAcA,IAAAA;AACzB;;;;;;;;;"}