@cratis/scene.primereact 1.1.0 → 3.0.0

package/dist/cjs/menu/PrimeDock.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeDock.js","sources":["../../../menu/PrimeDock.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 { Dock } from 'primereact/dock';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:dock` component - a macOS-style dock of magnifying icons.\n *\n * Dock positions itself absolutely against its nearest positioned ancestor, so it is wrapped in a sized\n * relative box; dropped straight into a Scene tree it would otherwise pin itself to the page.\n *\n * In PrimeReact 11 this component is removed with no direct replacement.\n */\nexport function PrimeDock({ element }: RegisteredComponentProps) {\n    return (\n        <div data-scene-id={element.id} className='relative h-40 w-full'>\n            <Dock model={menuItemsProperty(element, 'items')} position={stringProperty(element, 'position', 'bottom') as 'top' | 'bottom' | 'left' | 'right'} />\n        </div>\n    );\n}\n"],"names":["PrimeDock","element","_jsx","div","data-scene-id","id","className","Dock","model","menuItemsProperty","position","stringProperty"],"mappings":";;;;;;;AAQA;;;;;;;AAOC,IACM,SAASA,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;AAC3D,IAAA,qBACIC,cAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;QAAEC,SAAAA,EAAU,sBAAA;AACtC,QAAA,QAAA,gBAAAJ,cAAA,CAACK,SAAAA,EAAAA;AAAKC,YAAAA,KAAAA,EAAOC,4BAAkBR,OAAAA,EAAS,OAAA,CAAA;YAAUS,QAAAA,EAAUC,yBAAAA,CAAeV,SAAS,UAAA,EAAY,QAAA;;;AAG5G;;;;"}
+{"version":3,"file":"PrimeDock.js","sources":["../../../menu/PrimeDock.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { stringProperty } from '../properties';\nimport { Dock } from './Dock';\nimport { DockPosition } from './DockPosition';\n\n/**\n * Narrows an authored `position` onto the edges a dock can actually be anchored to.\n *\n * A screen's properties are authored data rather than compiler-checked values, so an unrecognized edge is\n * an ordinary thing to encounter. Falling back to the bottom edge - the dock's own default - keeps a\n * mistyped property behaving exactly like an absent one, which is the rule every reader in this package\n * follows.\n *\n * @param value The authored position.\n * @returns The matching edge, or the bottom edge when the value names none.\n */\nfunction dockPosition(value: string): DockPosition {\n    switch (value) {\n        case DockPosition.Top:\n            return DockPosition.Top;\n        case DockPosition.Left:\n            return DockPosition.Left;\n        case DockPosition.Right:\n            return DockPosition.Right;\n        default:\n            return DockPosition.Bottom;\n    }\n}\n\n/**\n * The `PrimeReact:dock` component - a strip of icons anchored to one edge.\n *\n * PrimeReact 11 removed `dock` with nothing to replace it, so what this adapts is Scene's own\n * {@link Dock}. The magnifying effect that made v10's dock recognizable is not part of the replacement;\n * what a screen actually depends on is a row of icon commands pinned to an edge, and that is what remains.\n *\n * A dock positions itself absolutely against its nearest positioned ancestor, so it is wrapped in a sized\n * relative box here; dropped straight into a Scene tree it would otherwise pin itself to the page.\n */\nexport function PrimeDock({ element }: RegisteredComponentProps) {\n    return (\n        <div data-scene-id={element.id} className='relative h-40 w-full'>\n            <Dock items={menuItemsProperty(element, 'items')} position={dockPosition(stringProperty(element, 'position', DockPosition.Bottom))} />\n        </div>\n    );\n}\n"],"names":["dockPosition","value","DockPosition","Top","Left","Right","Bottom","PrimeDock","element","_jsx","div","data-scene-id","id","className","Dock","items","menuItemsProperty","position","stringProperty"],"mappings":";;;;;;;;AAAA;AACA;AAQA;;;;;;;;;;IAWA,SAASA,aAAaC,KAAa,EAAA;IAC/B,OAAQA,KAAAA;AACJ,QAAA,KAAKC,0BAAaC,GAAG;AACjB,YAAA,OAAOD,0BAAaC,GAAG;AAC3B,QAAA,KAAKD,0BAAaE,IAAI;AAClB,YAAA,OAAOF,0BAAaE,IAAI;AAC5B,QAAA,KAAKF,0BAAaG,KAAK;AACnB,YAAA,OAAOH,0BAAaG,KAAK;AAC7B,QAAA;AACI,YAAA,OAAOH,0BAAaI,MAAM;AAClC;AACJ;AAEA;;;;;;;;;AASC,IACM,SAASC,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;AAC3D,IAAA,qBACIC,cAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;QAAEC,SAAAA,EAAU,sBAAA;AACtC,QAAA,QAAA,gBAAAJ,cAAA,CAACK,SAAAA,EAAAA;AAAKC,YAAAA,KAAAA,EAAOC,4BAAkBR,OAAAA,EAAS,OAAA,CAAA;AAAUS,YAAAA,QAAAA,EAAUjB,YAAAA,CAAakB,yBAAAA,CAAeV,OAAAA,EAAS,UAAA,EAAYN,0BAAaI,MAAM,CAAA;;;AAG5I;;;;"}

package/dist/cjs/menu/PrimeMegaMenu.js

@@ -1,21 +1,25 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var megamenu = require('primereact/megamenu');
 var menuItems = require('../menuItems.js');
-var properties = require('../properties.js');
+var MegaMenu = require('./MegaMenu.js');
 
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 /**
  * The `PrimeReact:megaMenu` component - a menubar whose submenus open as multi-column panels.
  *
- * MegaMenu reads its columns from a doubly nested `items` model: each root entry's `items` is a list of
- * columns, and each column's `items` is the commands in it. `menuItemsProperty` follows the nesting to
- * any depth, so an author writes that shape directly.
+ * PrimeReact 11 removed `megamenu` with nothing to replace it, so what this adapts is Scene's own
+ * {@link MegaMenu}.
+ *
+ * Columns are one ordinary level of nesting: each root entry's `items` are the columns, and each column's
+ * `items` are the commands in it. PrimeReact 10 spelled that as an array of arrays, but `menuItemsProperty`
+ * follows nested objects and drops nested arrays, so the doubly-nested form never survived the read in the
+ * first place. Authoring it as objects is both what the reader supports and one bracket less to get right.
  */ function PrimeMegaMenu({ element }) {
-    return /*#__PURE__*/ jsxRuntime.jsx(megamenu.MegaMenu, {
+    return /*#__PURE__*/ jsxRuntime.jsx(MegaMenu.MegaMenu, {
         "data-scene-id": element.id,
-        model: menuItems.menuItemsProperty(element, 'items'),
-        orientation: properties.stringProperty(element, 'orientation', 'horizontal')
+        items: menuItems.menuItemsProperty(element, 'items')
     });
 }
 

package/dist/cjs/menu/PrimeMegaMenu.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeMegaMenu.js","sources":["../../../menu/PrimeMegaMenu.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 { MegaMenu } from 'primereact/megamenu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:megaMenu` component - a menubar whose submenus open as multi-column panels.\n *\n * MegaMenu reads its columns from a doubly nested `items` model: each root entry's `items` is a list of\n * columns, and each column's `items` is the commands in it. `menuItemsProperty` follows the nesting to\n * any depth, so an author writes that shape directly.\n */\nexport function PrimeMegaMenu({ element }: RegisteredComponentProps) {\n    return (\n        <MegaMenu\n            data-scene-id={element.id}\n            model={menuItemsProperty(element, 'items')}\n            orientation={stringProperty(element, 'orientation', 'horizontal') as 'horizontal' | 'vertical'}\n        />\n    );\n}\n"],"names":["PrimeMegaMenu","element","_jsx","MegaMenu","data-scene-id","id","model","menuItemsProperty","orientation","stringProperty"],"mappings":";;;;;;;AAQA;;;;;;AAMC,IACM,SAASA,aAAAA,CAAc,EAAEC,OAAO,EAA4B,EAAA;AAC/D,IAAA,qBACIC,cAAA,CAACC,iBAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA,CAAA;QAClCO,WAAAA,EAAaC,yBAAAA,CAAeR,SAAS,aAAA,EAAe,YAAA;;AAGhE;;;;"}
+{"version":3,"file":"PrimeMegaMenu.js","sources":["../../../menu/PrimeMegaMenu.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { MegaMenu } from './MegaMenu';\n\n/**\n * The `PrimeReact:megaMenu` component - a menubar whose submenus open as multi-column panels.\n *\n * PrimeReact 11 removed `megamenu` with nothing to replace it, so what this adapts is Scene's own\n * {@link MegaMenu}.\n *\n * Columns are one ordinary level of nesting: each root entry's `items` are the columns, and each column's\n * `items` are the commands in it. PrimeReact 10 spelled that as an array of arrays, but `menuItemsProperty`\n * follows nested objects and drops nested arrays, so the doubly-nested form never survived the read in the\n * first place. Authoring it as objects is both what the reader supports and one bracket less to get right.\n */\nexport function PrimeMegaMenu({ element }: RegisteredComponentProps) {\n    return <MegaMenu data-scene-id={element.id} items={menuItemsProperty(element, 'items')} />;\n}\n"],"names":["PrimeMegaMenu","element","_jsx","MegaMenu","data-scene-id","id","items","menuItemsProperty"],"mappings":";;;;;;AAAA;AACA;AAMA;;;;;;;;;;AAUC,IACM,SAASA,aAAAA,CAAc,EAAEC,OAAO,EAA4B,EAAA;AAC/D,IAAA,qBAAOC,cAAA,CAACC,iBAAAA,EAAAA;AAASC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA;;AAClF;;;;"}

package/dist/cjs/menu/PrimeMenu.js

@@ -3,13 +3,69 @@
 var jsxRuntime = require('react/jsx-runtime');
 var menu = require('primereact/menu');
 var menuItems = require('../menuItems.js');
+var MenuItemContent = require('./MenuItemContent.js');
 
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * One selectable entry, as either a command or a link depending on whether the entry names a target.
+ *
+ * `Menu.Item` renders whatever element `as` names, so the link case is the same part with an anchor
+ * underneath rather than a different code path - which is what keeps the menu's own keyboard handling,
+ * focus tracking and identifiers working for both kinds of entry.
+ *
+ * @param item The entry to render.
+ * @param value The entry's identity within the menu, which the menu turns into a stable element id.
+ * @returns The rendered entry.
+ */ function menuEntry(item, value) {
+    return /*#__PURE__*/ jsxRuntime.jsx(menu.Menu.Item, {
+        value: value,
+        as: item.url === undefined ? 'div' : 'a',
+        href: item.url,
+        disabled: item.disabled,
+        onSelect: ()=>item.command?.(),
+        children: /*#__PURE__*/ jsxRuntime.jsx(MenuItemContent.MenuItemContent, {
+            item: item
+        })
+    }, value);
+}
 /**
  * The `PrimeReact:menu` component - a flat list of commands.
+ *
+ * PrimeReact 11 turned `Menu` from one component taking a `model` array into a namespace of parts that a
+ * caller assembles, so the adapter now walks the item model itself. That is more lines, but it is the only
+ * way to reach the parts, and it buys the thing the `model` prop never allowed: an entry can be an anchor
+ * when it navigates and a plain item when it commands.
+ *
+ * `Menu.Root` renders no element of its own unless told which one to be, so `as` is given explicitly -
+ * without it the root collapses to a fragment and takes the element's `data-scene-id` and the theme's own
+ * scope attributes with it.
+ *
+ * An entry that carries children is rendered as a labeled group rather than being flattened to its own
+ * label, which is what the v10 `Menu` did with a nested entry. Dropping the children instead would lose
+ * authored content silently; a menu that genuinely needs a *side-opening* submenu is a `tieredMenu`.
  */ function PrimeMenu({ element }) {
-    return /*#__PURE__*/ jsxRuntime.jsx(menu.Menu, {
+    const items = menuItems.menuItemsProperty(element, 'items');
+    return /*#__PURE__*/ jsxRuntime.jsx(menu.Menu.Root, {
+        as: "div",
         "data-scene-id": element.id,
-        model: menuItems.menuItemsProperty(element, 'items')
+        children: /*#__PURE__*/ jsxRuntime.jsx(menu.Menu.List, {
+            children: items.map((item, index)=>{
+                if (item.separator === true) return /*#__PURE__*/ jsxRuntime.jsx(menu.Menu.Separator, {}, index);
+                const children = item.items ?? [];
+                if (children.length === 0) return menuEntry(item, `${index}`);
+                return /*#__PURE__*/ jsxRuntime.jsxs(menu.Menu.Group, {
+                    children: [
+                        /*#__PURE__*/ jsxRuntime.jsx(menu.Menu.Label, {
+                            children: /*#__PURE__*/ jsxRuntime.jsx(MenuItemContent.MenuItemContent, {
+                                item: item
+                            })
+                        }),
+                        children.map((child, childIndex)=>menuEntry(child, `${index}-${childIndex}`))
+                    ]
+                }, index);
+            })
+        })
     });
 }
 

package/dist/cjs/menu/PrimeMenu.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeMenu.js","sources":["../../../menu/PrimeMenu.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 { Menu } from 'primereact/menu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\n\n/**\n * The `PrimeReact:menu` component - a flat list of commands.\n */\nexport function PrimeMenu({ element }: RegisteredComponentProps) {\n    return <Menu data-scene-id={element.id} model={menuItemsProperty(element, 'items')} />;\n}\n"],"names":["PrimeMenu","element","_jsx","Menu","data-scene-id","id","model","menuItemsProperty"],"mappings":";;;;;;AAOA;;AAEC,IACM,SAASA,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;AAC3D,IAAA,qBAAOC,cAAA,CAACC,SAAAA,EAAAA;AAAKC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA;;AAC9E;;;;"}
+{"version":3,"file":"PrimeMenu.js","sources":["../../../menu/PrimeMenu.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 } from 'react';\nimport { Menu } from 'primereact/menu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { MenuItem } from '../MenuItem';\nimport { menuItemsProperty } from '../menuItems';\nimport { MenuItemContent } from './MenuItemContent';\n\n/**\n * One selectable entry, as either a command or a link depending on whether the entry names a target.\n *\n * `Menu.Item` renders whatever element `as` names, so the link case is the same part with an anchor\n * underneath rather than a different code path - which is what keeps the menu's own keyboard handling,\n * focus tracking and identifiers working for both kinds of entry.\n *\n * @param item The entry to render.\n * @param value The entry's identity within the menu, which the menu turns into a stable element id.\n * @returns The rendered entry.\n */\nfunction menuEntry(item: MenuItem, value: string): ReactNode {\n    return (\n        <Menu.Item\n            key={value}\n            value={value}\n            as={item.url === undefined ? 'div' : 'a'}\n            href={item.url}\n            disabled={item.disabled}\n            onSelect={() => item.command?.()}>\n            <MenuItemContent item={item} />\n        </Menu.Item>\n    );\n}\n\n/**\n * The `PrimeReact:menu` component - a flat list of commands.\n *\n * PrimeReact 11 turned `Menu` from one component taking a `model` array into a namespace of parts that a\n * caller assembles, so the adapter now walks the item model itself. That is more lines, but it is the only\n * way to reach the parts, and it buys the thing the `model` prop never allowed: an entry can be an anchor\n * when it navigates and a plain item when it commands.\n *\n * `Menu.Root` renders no element of its own unless told which one to be, so `as` is given explicitly -\n * without it the root collapses to a fragment and takes the element's `data-scene-id` and the theme's own\n * scope attributes with it.\n *\n * An entry that carries children is rendered as a labeled group rather than being flattened to its own\n * label, which is what the v10 `Menu` did with a nested entry. Dropping the children instead would lose\n * authored content silently; a menu that genuinely needs a *side-opening* submenu is a `tieredMenu`.\n */\nexport function PrimeMenu({ element }: RegisteredComponentProps) {\n    const items = menuItemsProperty(element, 'items');\n\n    return (\n        <Menu.Root as='div' data-scene-id={element.id}>\n            <Menu.List>\n                {items.map((item, index) => {\n                    if (item.separator === true) return <Menu.Separator key={index} />;\n\n                    const children = item.items ?? [];\n                    if (children.length === 0) return menuEntry(item, `${index}`);\n\n                    return (\n                        <Menu.Group key={index}>\n                            <Menu.Label>\n                                <MenuItemContent item={item} />\n                            </Menu.Label>\n                            {children.map((child, childIndex) => menuEntry(child, `${index}-${childIndex}`))}\n                        </Menu.Group>\n                    );\n                })}\n            </Menu.List>\n        </Menu.Root>\n    );\n}\n"],"names":["menuEntry","item","value","_jsx","Menu","Item","as","url","undefined","href","disabled","onSelect","command","MenuItemContent","PrimeMenu","element","items","menuItemsProperty","Root","data-scene-id","id","List","map","index","separator","Separator","children","length","_jsxs","Group","Label","child","childIndex"],"mappings":";;;;;;;AAAA;AACA;AASA;;;;;;;;;;AAUC,IACD,SAASA,SAAAA,CAAUC,IAAc,EAAEC,KAAa,EAAA;IAC5C,qBACIC,cAAA,CAACC,UAAKC,IAAI,EAAA;QAENH,KAAAA,EAAOA,KAAAA;AACPI,QAAAA,EAAAA,EAAIL,IAAAA,CAAKM,GAAG,KAAKC,SAAAA,GAAY,KAAA,GAAQ,GAAA;AACrCC,QAAAA,IAAAA,EAAMR,KAAKM,GAAG;AACdG,QAAAA,QAAAA,EAAUT,KAAKS,QAAQ;QACvBC,QAAAA,EAAU,IAAMV,KAAKW,OAAO,IAAA;AAC5B,QAAA,QAAA,gBAAAT,cAAA,CAACU,+BAAAA,EAAAA;YAAgBZ,IAAAA,EAAMA;;AANlBC,KAAAA,EAAAA,KAAAA,CAAAA;AASjB;AAEA;;;;;;;;;;;;;;;AAeC,IACM,SAASY,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;IAC3D,MAAMC,KAAAA,GAAQC,4BAAkBF,OAAAA,EAAS,OAAA,CAAA;IAEzC,qBACIZ,cAAA,CAACC,UAAKc,IAAI,EAAA;QAACZ,EAAAA,EAAG,KAAA;AAAMa,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;gCACzCjB,cAAA,CAACC,UAAKiB,IAAI,EAAA;sBACLL,KAAAA,CAAMM,GAAG,CAAC,CAACrB,IAAAA,EAAMsB,KAAAA,GAAAA;gBACd,IAAItB,IAAAA,CAAKuB,SAAS,KAAK,IAAA,EAAM,qBAAOrB,cAAA,CAACC,SAAAA,CAAKqB,SAAS,EAAA,EAAA,EAAMF,KAAAA,CAAAA;AAEzD,gBAAA,MAAMG,QAAAA,GAAWzB,IAAAA,CAAKe,KAAK,IAAI,EAAE;gBACjC,IAAIU,QAAAA,CAASC,MAAM,KAAK,CAAA,EAAG,OAAO3B,SAAAA,CAAUC,IAAAA,EAAM,GAAGsB,KAAAA,CAAAA,CAAO,CAAA;gBAE5D,qBACIK,eAAA,CAACxB,UAAKyB,KAAK,EAAA;;AACP,sCAAA1B,cAAA,CAACC,UAAK0B,KAAK,EAAA;AACP,4BAAA,QAAA,gBAAA3B,cAAA,CAACU,+BAAAA,EAAAA;gCAAgBZ,IAAAA,EAAMA;;;wBAE1ByB,QAAAA,CAASJ,GAAG,CAAC,CAACS,KAAAA,EAAOC,UAAAA,GAAehC,SAAAA,CAAU+B,KAAAA,EAAO,CAAA,EAAGR,KAAAA,CAAM,CAAC,EAAES,UAAAA,CAAAA,CAAY,CAAA;;AAJjET,iBAAAA,EAAAA,KAAAA,CAAAA;AAOzB,YAAA,CAAA;;;AAIhB;;;;"}

package/dist/cjs/menu/PrimeMenubar.js

@@ -1,18 +1,25 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var menubar = require('primereact/menubar');
 var menuItems = require('../menuItems.js');
+var Menubar = require('./Menubar.js');
 
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 /**
  * The `PrimeReact:menubar` component - a horizontal menu with nested submenus.
  *
  * The `start` and `end` slots take the branding and account controls that flank a real application's
  * menubar; the commands themselves come from the `items` property.
+ *
+ * PrimeReact 11 removed `menubar` with nothing to replace it, so what this adapts is Scene's own
+ * {@link Menubar}. The registered name and the authored properties are unchanged, which is the point -
+ * a screen written against the PrimeReact 10 package keeps working, and the substitution shows up as a
+ * shorter list of behaviors rather than as a broken screen.
  */ function PrimeMenubar({ element, slots }) {
-    return /*#__PURE__*/ jsxRuntime.jsx(menubar.Menubar, {
+    return /*#__PURE__*/ jsxRuntime.jsx(Menubar.Menubar, {
         "data-scene-id": element.id,
-        model: menuItems.menuItemsProperty(element, 'items'),
+        items: menuItems.menuItemsProperty(element, 'items'),
         start: slots.start,
         end: slots.end
     });

package/dist/cjs/menu/PrimeMenubar.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeMenubar.js","sources":["../../../menu/PrimeMenubar.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 { Menubar } from 'primereact/menubar';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\n\n/**\n * The `PrimeReact:menubar` component - a horizontal menu with nested submenus.\n *\n * The `start` and `end` slots take the branding and account controls that flank a real application's\n * menubar; the commands themselves come from the `items` property.\n */\nexport function PrimeMenubar({ element, slots }: RegisteredComponentProps) {\n    return <Menubar data-scene-id={element.id} model={menuItemsProperty(element, 'items')} start={slots.start} end={slots.end} />;\n}\n"],"names":["PrimeMenubar","element","slots","_jsx","Menubar","data-scene-id","id","model","menuItemsProperty","start","end"],"mappings":";;;;;;AAOA;;;;;AAKC,IACM,SAASA,YAAAA,CAAa,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACrE,IAAA,qBAAOC,cAAA,CAACC,eAAAA,EAAAA;AAAQC,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBP,OAAAA,EAAS,OAAA,CAAA;AAAUQ,QAAAA,KAAAA,EAAOP,MAAMO,KAAK;AAAEC,QAAAA,GAAAA,EAAKR,MAAMQ;;AAC1H;;;;"}
+{"version":3,"file":"PrimeMenubar.js","sources":["../../../menu/PrimeMenubar.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { Menubar } from './Menubar';\n\n/**\n * The `PrimeReact:menubar` component - a horizontal menu with nested submenus.\n *\n * The `start` and `end` slots take the branding and account controls that flank a real application's\n * menubar; the commands themselves come from the `items` property.\n *\n * PrimeReact 11 removed `menubar` with nothing to replace it, so what this adapts is Scene's own\n * {@link Menubar}. The registered name and the authored properties are unchanged, which is the point -\n * a screen written against the PrimeReact 10 package keeps working, and the substitution shows up as a\n * shorter list of behaviors rather than as a broken screen.\n */\nexport function PrimeMenubar({ element, slots }: RegisteredComponentProps) {\n    return <Menubar data-scene-id={element.id} items={menuItemsProperty(element, 'items')} start={slots.start} end={slots.end} />;\n}\n"],"names":["PrimeMenubar","element","slots","_jsx","Menubar","data-scene-id","id","items","menuItemsProperty","start","end"],"mappings":";;;;;;AAAA;AACA;AAMA;;;;;;;;;;AAUC,IACM,SAASA,YAAAA,CAAa,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACrE,IAAA,qBAAOC,cAAA,CAACC,eAAAA,EAAAA;AAAQC,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBP,OAAAA,EAAS,OAAA,CAAA;AAAUQ,QAAAA,KAAAA,EAAOP,MAAMO,KAAK;AAAEC,QAAAA,GAAAA,EAAKR,MAAMQ;;AAC1H;;;;"}

package/dist/cjs/menu/PrimePanelMenu.js

@@ -1,18 +1,23 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var panelmenu = require('primereact/panelmenu');
 var menuItems = require('../menuItems.js');
 var properties = require('../properties.js');
+var PanelMenu = require('./PanelMenu.js');
 
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 /**
  * The `PrimeReact:panelMenu` component - a vertical menu whose submenus expand in place, accordion style.
  *
- * In PrimeReact 11 this component is removed with no direct replacement.
+ * PrimeReact 11 removed `panelmenu` with nothing to replace it, so what this adapts is Scene's own
+ * {@link PanelMenu}. That replacement is the least hand-rolled of the seven in this folder: v11 still ships
+ * `accordion`, and an accordion is exactly what a panel menu's expand-and-collapse behavior is, so only the
+ * mapping from the authored item model onto those parts is Scene's.
  */ function PrimePanelMenu({ element }) {
-    return /*#__PURE__*/ jsxRuntime.jsx(panelmenu.PanelMenu, {
+    return /*#__PURE__*/ jsxRuntime.jsx(PanelMenu.PanelMenu, {
         "data-scene-id": element.id,
-        model: menuItems.menuItemsProperty(element, 'items'),
+        items: menuItems.menuItemsProperty(element, 'items'),
         multiple: properties.booleanProperty(element, 'multiple', false)
     });
 }

package/dist/cjs/menu/PrimePanelMenu.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimePanelMenu.js","sources":["../../../menu/PrimePanelMenu.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 { PanelMenu } from 'primereact/panelmenu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { booleanProperty } from '../properties';\n\n/**\n * The `PrimeReact:panelMenu` component - a vertical menu whose submenus expand in place, accordion style.\n *\n * In PrimeReact 11 this component is removed with no direct replacement.\n */\nexport function PrimePanelMenu({ element }: RegisteredComponentProps) {\n    return (\n        <PanelMenu data-scene-id={element.id} model={menuItemsProperty(element, 'items')} multiple={booleanProperty(element, 'multiple', false)} />\n    );\n}\n"],"names":["PrimePanelMenu","element","_jsx","PanelMenu","data-scene-id","id","model","menuItemsProperty","multiple","booleanProperty"],"mappings":";;;;;;;AAQA;;;;AAIC,IACM,SAASA,cAAAA,CAAe,EAAEC,OAAO,EAA4B,EAAA;AAChE,IAAA,qBACIC,cAAA,CAACC,mBAAAA,EAAAA;AAAUC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,QAAAA,EAAUC,0BAAAA,CAAgBR,SAAS,UAAA,EAAY,KAAA;;AAEzI;;;;"}
+{"version":3,"file":"PrimePanelMenu.js","sources":["../../../menu/PrimePanelMenu.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { booleanProperty } from '../properties';\nimport { PanelMenu } from './PanelMenu';\n\n/**\n * The `PrimeReact:panelMenu` component - a vertical menu whose submenus expand in place, accordion style.\n *\n * PrimeReact 11 removed `panelmenu` with nothing to replace it, so what this adapts is Scene's own\n * {@link PanelMenu}. That replacement is the least hand-rolled of the seven in this folder: v11 still ships\n * `accordion`, and an accordion is exactly what a panel menu's expand-and-collapse behavior is, so only the\n * mapping from the authored item model onto those parts is Scene's.\n */\nexport function PrimePanelMenu({ element }: RegisteredComponentProps) {\n    return <PanelMenu data-scene-id={element.id} items={menuItemsProperty(element, 'items')} multiple={booleanProperty(element, 'multiple', false)} />;\n}\n"],"names":["PrimePanelMenu","element","_jsx","PanelMenu","data-scene-id","id","items","menuItemsProperty","multiple","booleanProperty"],"mappings":";;;;;;;AAAA;AACA;AAOA;;;;;;;AAOC,IACM,SAASA,cAAAA,CAAe,EAAEC,OAAO,EAA4B,EAAA;AAChE,IAAA,qBAAOC,cAAA,CAACC,mBAAAA,EAAAA;AAAUC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,QAAAA,EAAUC,0BAAAA,CAAgBR,SAAS,UAAA,EAAY,KAAA;;AAC5I;;;;"}

package/dist/cjs/menu/PrimeSteps.js

@@ -1,24 +1,30 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var react = require('react');
-var steps = require('primereact/steps');
 var menuItems = require('../menuItems.js');
 var properties = require('../properties.js');
+var Steps = require('./Steps.js');
 
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 /**
  * The `PrimeReact:steps` component - progress through a sequence, shown as numbered labels.
  *
- * Unlike `stepper` this shows position only and owns no content; a screen pairs it with whatever it
- * wants to render per step.
+ * Unlike `stepper` this shows position only and owns no content; a screen pairs it with whatever it wants
+ * to render per step.
+ *
+ * PrimeReact 11 removed `steps` with nothing to replace it - `stepper` survives, but it owns the content of
+ * each step and drives moving between them, which is the other component Scene already registers - so what
+ * this adapts is Scene's own {@link Steps}.
+ *
+ * The position is now read straight from the element on every render rather than seeded into local state.
+ * Scene's own {@link Steps} is a read-only indicator, so there is nothing left that could move the position
+ * behind the authored value's back, and holding a copy of it would only let the two disagree.
  */ function PrimeSteps({ element }) {
-    const [activeIndex, setActiveIndex] = react.useState(properties.numberProperty(element, 'activeIndex', 0));
-    return /*#__PURE__*/ jsxRuntime.jsx(steps.Steps, {
+    return /*#__PURE__*/ jsxRuntime.jsx(Steps.Steps, {
         "data-scene-id": element.id,
-        model: menuItems.menuItemsProperty(element, 'items'),
-        activeIndex: activeIndex,
-        readOnly: properties.booleanProperty(element, 'readOnly', false),
-        onSelect: (event)=>setActiveIndex(event.index)
+        items: menuItems.menuItemsProperty(element, 'items'),
+        activeIndex: properties.numberProperty(element, 'activeIndex', 0)
     });
 }
 

package/dist/cjs/menu/PrimeSteps.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeSteps.js","sources":["../../../menu/PrimeSteps.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 { useState } from 'react';\nimport { Steps } from 'primereact/steps';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { booleanProperty, numberProperty } from '../properties';\n\n/**\n * The `PrimeReact:steps` component - progress through a sequence, shown as numbered labels.\n *\n * Unlike `stepper` this shows position only and owns no content; a screen pairs it with whatever it\n * wants to render per step.\n */\nexport function PrimeSteps({ element }: RegisteredComponentProps) {\n    const [activeIndex, setActiveIndex] = useState(numberProperty(element, 'activeIndex', 0));\n    return (\n        <Steps\n            data-scene-id={element.id}\n            model={menuItemsProperty(element, 'items')}\n            activeIndex={activeIndex}\n            readOnly={booleanProperty(element, 'readOnly', false)}\n            onSelect={(event) => setActiveIndex(event.index)}\n        />\n    );\n}\n"],"names":["PrimeSteps","element","activeIndex","setActiveIndex","useState","numberProperty","_jsx","Steps","data-scene-id","id","model","menuItemsProperty","readOnly","booleanProperty","onSelect","event","index"],"mappings":";;;;;;;;AASA;;;;;AAKC,IACM,SAASA,UAAAA,CAAW,EAAEC,OAAO,EAA4B,EAAA;AAC5D,IAAA,MAAM,CAACC,WAAAA,EAAaC,cAAAA,CAAe,GAAGC,cAAAA,CAASC,yBAAAA,CAAeJ,SAAS,aAAA,EAAe,CAAA,CAAA,CAAA;AACtF,IAAA,qBACIK,cAAA,CAACC,WAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,4BAAkBV,OAAAA,EAAS,OAAA,CAAA;QAClCC,WAAAA,EAAaA,WAAAA;QACbU,QAAAA,EAAUC,0BAAAA,CAAgBZ,SAAS,UAAA,EAAY,KAAA,CAAA;AAC/Ca,QAAAA,QAAAA,EAAU,CAACC,KAAAA,GAAUZ,cAAAA,CAAeY,KAAAA,CAAMC,KAAK;;AAG3D;;;;"}
+{"version":3,"file":"PrimeSteps.js","sources":["../../../menu/PrimeSteps.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { numberProperty } from '../properties';\nimport { Steps } from './Steps';\n\n/**\n * The `PrimeReact:steps` component - progress through a sequence, shown as numbered labels.\n *\n * Unlike `stepper` this shows position only and owns no content; a screen pairs it with whatever it wants\n * to render per step.\n *\n * PrimeReact 11 removed `steps` with nothing to replace it - `stepper` survives, but it owns the content of\n * each step and drives moving between them, which is the other component Scene already registers - so what\n * this adapts is Scene's own {@link Steps}.\n *\n * The position is now read straight from the element on every render rather than seeded into local state.\n * Scene's own {@link Steps} is a read-only indicator, so there is nothing left that could move the position\n * behind the authored value's back, and holding a copy of it would only let the two disagree.\n */\nexport function PrimeSteps({ element }: RegisteredComponentProps) {\n    return <Steps data-scene-id={element.id} items={menuItemsProperty(element, 'items')} activeIndex={numberProperty(element, 'activeIndex', 0)} />;\n}\n"],"names":["PrimeSteps","element","_jsx","Steps","data-scene-id","id","items","menuItemsProperty","activeIndex","numberProperty"],"mappings":";;;;;;;AAAA;AACA;AAOA;;;;;;;;;;;;;AAaC,IACM,SAASA,UAAAA,CAAW,EAAEC,OAAO,EAA4B,EAAA;AAC5D,IAAA,qBAAOC,cAAA,CAACC,WAAAA,EAAAA;AAAMC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,WAAAA,EAAaC,yBAAAA,CAAeR,SAAS,aAAA,EAAe,CAAA;;AAC7I;;;;"}

package/dist/cjs/menu/PrimeTabMenu.js

@@ -1,24 +1,27 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var react = require('react');
-var tabmenu = require('primereact/tabmenu');
 var menuItems = require('../menuItems.js');
 var properties = require('../properties.js');
+var TabMenu = require('./TabMenu.js');
 
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 /**
  * The `PrimeReact:tabMenu` component - tabs used for navigation rather than for hiding content.
  *
- * The selected tab is held locally so the control responds to clicks in a preview.
+ * PrimeReact 11 removed `tabmenu` with nothing to replace it, so what this adapts is Scene's own
+ * {@link TabMenu}. `primereact/tabs` does exist in v11 and looks like the obvious substitute, but it is
+ * built for tabs that control panels; a navigation bar has none, and adopting it would announce panels
+ * that are not there. Scene's replacement keeps the look and tells the truth about the semantics.
  *
- * In PrimeReact 11 this component is removed; navigation tabs are built from `Tabs` instead.
+ * The selected entry is held by the component itself so the control responds to clicks in a preview,
+ * exactly as the v10 adapter did; the authored `activeIndex` is where it starts.
  */ function PrimeTabMenu({ element }) {
-    const [activeIndex, setActiveIndex] = react.useState(properties.numberProperty(element, 'activeIndex', 0));
-    return /*#__PURE__*/ jsxRuntime.jsx(tabmenu.TabMenu, {
+    return /*#__PURE__*/ jsxRuntime.jsx(TabMenu.TabMenu, {
         "data-scene-id": element.id,
-        model: menuItems.menuItemsProperty(element, 'items'),
-        activeIndex: activeIndex,
-        onTabChange: (event)=>setActiveIndex(event.index)
+        items: menuItems.menuItemsProperty(element, 'items'),
+        activeIndex: properties.numberProperty(element, 'activeIndex', 0)
     });
 }
 

package/dist/cjs/menu/PrimeTabMenu.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeTabMenu.js","sources":["../../../menu/PrimeTabMenu.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 { useState } from 'react';\nimport { TabMenu } from 'primereact/tabmenu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { numberProperty } from '../properties';\n\n/**\n * The `PrimeReact:tabMenu` component - tabs used for navigation rather than for hiding content.\n *\n * The selected tab is held locally so the control responds to clicks in a preview.\n *\n * In PrimeReact 11 this component is removed; navigation tabs are built from `Tabs` instead.\n */\nexport function PrimeTabMenu({ element }: RegisteredComponentProps) {\n    const [activeIndex, setActiveIndex] = useState(numberProperty(element, 'activeIndex', 0));\n    return (\n        <TabMenu\n            data-scene-id={element.id}\n            model={menuItemsProperty(element, 'items')}\n            activeIndex={activeIndex}\n            onTabChange={(event) => setActiveIndex(event.index)}\n        />\n    );\n}\n"],"names":["PrimeTabMenu","element","activeIndex","setActiveIndex","useState","numberProperty","_jsx","TabMenu","data-scene-id","id","model","menuItemsProperty","onTabChange","event","index"],"mappings":";;;;;;;;AASA;;;;;;AAMC,IACM,SAASA,YAAAA,CAAa,EAAEC,OAAO,EAA4B,EAAA;AAC9D,IAAA,MAAM,CAACC,WAAAA,EAAaC,cAAAA,CAAe,GAAGC,cAAAA,CAASC,yBAAAA,CAAeJ,SAAS,aAAA,EAAe,CAAA,CAAA,CAAA;AACtF,IAAA,qBACIK,cAAA,CAACC,eAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,4BAAkBV,OAAAA,EAAS,OAAA,CAAA;QAClCC,WAAAA,EAAaA,WAAAA;AACbU,QAAAA,WAAAA,EAAa,CAACC,KAAAA,GAAUV,cAAAA,CAAeU,KAAAA,CAAMC,KAAK;;AAG9D;;;;"}
+{"version":3,"file":"PrimeTabMenu.js","sources":["../../../menu/PrimeTabMenu.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { numberProperty } from '../properties';\nimport { TabMenu } from './TabMenu';\n\n/**\n * The `PrimeReact:tabMenu` component - tabs used for navigation rather than for hiding content.\n *\n * PrimeReact 11 removed `tabmenu` with nothing to replace it, so what this adapts is Scene's own\n * {@link TabMenu}. `primereact/tabs` does exist in v11 and looks like the obvious substitute, but it is\n * built for tabs that control panels; a navigation bar has none, and adopting it would announce panels\n * that are not there. Scene's replacement keeps the look and tells the truth about the semantics.\n *\n * The selected entry is held by the component itself so the control responds to clicks in a preview,\n * exactly as the v10 adapter did; the authored `activeIndex` is where it starts.\n */\nexport function PrimeTabMenu({ element }: RegisteredComponentProps) {\n    return <TabMenu data-scene-id={element.id} items={menuItemsProperty(element, 'items')} activeIndex={numberProperty(element, 'activeIndex', 0)} />;\n}\n"],"names":["PrimeTabMenu","element","_jsx","TabMenu","data-scene-id","id","items","menuItemsProperty","activeIndex","numberProperty"],"mappings":";;;;;;;AAAA;AACA;AAOA;;;;;;;;;;AAUC,IACM,SAASA,YAAAA,CAAa,EAAEC,OAAO,EAA4B,EAAA;AAC9D,IAAA,qBAAOC,cAAA,CAACC,eAAAA,EAAAA;AAAQC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,WAAAA,EAAaC,yBAAAA,CAAeR,SAAS,aAAA,EAAe,CAAA;;AAC/I;;;;"}

package/dist/cjs/menu/PrimeTieredMenu.js

@@ -1,15 +1,21 @@
 'use strict';
 
 var jsxRuntime = require('react/jsx-runtime');
-var tieredmenu = require('primereact/tieredmenu');
 var menuItems = require('../menuItems.js');
+var TieredMenu = require('./TieredMenu.js');
 
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 /**
  * The `PrimeReact:tieredMenu` component - a vertical menu whose submenus open to the side.
+ *
+ * PrimeReact 11 removed `tieredmenu` with nothing to replace it, so what this adapts is Scene's own
+ * {@link TieredMenu}. It is the one component in this family that keeps unlimited nesting, which is why an
+ * authored menu that genuinely goes three levels deep belongs here rather than in a `menubar`.
  */ function PrimeTieredMenu({ element }) {
-    return /*#__PURE__*/ jsxRuntime.jsx(tieredmenu.TieredMenu, {
+    return /*#__PURE__*/ jsxRuntime.jsx(TieredMenu.TieredMenu, {
         "data-scene-id": element.id,
-        model: menuItems.menuItemsProperty(element, 'items')
+        items: menuItems.menuItemsProperty(element, 'items')
     });
 }
 

package/dist/cjs/menu/PrimeTieredMenu.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeTieredMenu.js","sources":["../../../menu/PrimeTieredMenu.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 { TieredMenu } from 'primereact/tieredmenu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\n\n/**\n * The `PrimeReact:tieredMenu` component - a vertical menu whose submenus open to the side.\n */\nexport function PrimeTieredMenu({ element }: RegisteredComponentProps) {\n    return <TieredMenu data-scene-id={element.id} model={menuItemsProperty(element, 'items')} />;\n}\n"],"names":["PrimeTieredMenu","element","_jsx","TieredMenu","data-scene-id","id","model","menuItemsProperty"],"mappings":";;;;;;AAOA;;AAEC,IACM,SAASA,eAAAA,CAAgB,EAAEC,OAAO,EAA4B,EAAA;AACjE,IAAA,qBAAOC,cAAA,CAACC,qBAAAA,EAAAA;AAAWC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA;;AACpF;;;;"}
+{"version":3,"file":"PrimeTieredMenu.js","sources":["../../../menu/PrimeTieredMenu.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { TieredMenu } from './TieredMenu';\n\n/**\n * The `PrimeReact:tieredMenu` component - a vertical menu whose submenus open to the side.\n *\n * PrimeReact 11 removed `tieredmenu` with nothing to replace it, so what this adapts is Scene's own\n * {@link TieredMenu}. It is the one component in this family that keeps unlimited nesting, which is why an\n * authored menu that genuinely goes three levels deep belongs here rather than in a `menubar`.\n */\nexport function PrimeTieredMenu({ element }: RegisteredComponentProps) {\n    return <TieredMenu data-scene-id={element.id} items={menuItemsProperty(element, 'items')} />;\n}\n"],"names":["PrimeTieredMenu","element","_jsx","TieredMenu","data-scene-id","id","items","menuItemsProperty"],"mappings":";;;;;;AAAA;AACA;AAMA;;;;;;AAMC,IACM,SAASA,eAAAA,CAAgB,EAAEC,OAAO,EAA4B,EAAA;AACjE,IAAA,qBAAOC,cAAA,CAACC,qBAAAA,EAAAA;AAAWC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA;;AACpF;;;;"}

package/dist/cjs/menu/Steps.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var MenuItemContent = require('./MenuItemContent.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+const listStyle = {
+    listStyle: 'none',
+    margin: 0,
+    padding: 0,
+    color: 'var(--scene-text-color)'
+};
+const markerStyle = {
+    width: '1.75rem',
+    height: '1.75rem',
+    borderRadius: '50%',
+    border: '1px solid var(--scene-surface-border)',
+    background: 'var(--scene-surface-card)',
+    color: 'var(--scene-text-muted-color)'
+};
+const reachedMarkerStyle = {
+    ...markerStyle,
+    background: 'var(--scene-primary-color)',
+    borderColor: 'var(--scene-primary-color)',
+    color: 'var(--scene-primary-contrast-color)'
+};
+const pendingStepStyle = {
+    color: 'var(--scene-text-muted-color)'
+};
+/**
+ * A numbered horizontal indicator of where the user is in a sequence. Cratis-owned.
+ *
+ * This exists because PrimeReact 11 removed `primereact/steps` outright. `primereact/stepper` survives,
+ * but it is not a replacement: a stepper owns the content of each step and drives moving between them,
+ * whereas `steps` shows position and nothing else, next to whatever a screen chose to render itself. Scene
+ * has both concepts and they are registered separately, so collapsing one into the other would silently
+ * change what an authored screen means.
+ *
+ * It is an ordered list because that is what it is - a numbered sequence, read in order - and the step the
+ * user is on is marked with `aria-current` rather than only with color, so the position is available to a
+ * screen reader and not just to an eye.
+ *
+ * What it deliberately does not carry over from the v10 `Steps`: the indicator is read-only, so v10's
+ * `readOnly={false}` mode where clicking a step jumped to it is gone, and with it the `onSelect` callback
+ * and the internally held selection. A screen that wants navigable steps should hold the position itself
+ * and render whatever control it wants to move between them. Item templates and the vertical layout are
+ * not supported either.
+ */ function Steps({ items = [], activeIndex = 0, ...rest }) {
+    return /*#__PURE__*/ jsxRuntime.jsx("ol", {
+        ...rest,
+        className: "flex items-center gap-4",
+        style: listStyle,
+        children: items.map((item, index)=>/*#__PURE__*/ jsxRuntime.jsxs("li", {
+                className: "inline-flex items-center gap-2",
+                style: index <= activeIndex ? undefined : pendingStepStyle,
+                "aria-current": index === activeIndex ? 'step' : undefined,
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsx("span", {
+                        className: "inline-flex items-center justify-center",
+                        "aria-hidden": "true",
+                        style: index <= activeIndex ? reachedMarkerStyle : markerStyle,
+                        children: index + 1
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsx(MenuItemContent.MenuItemContent, {
+                        item: item
+                    })
+                ]
+            }, index))
+    });
+}
+
+exports.Steps = Steps;
+//# sourceMappingURL=Steps.js.map

package/dist/cjs/menu/Steps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Steps.js","sources":["../../../menu/Steps.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 { CSSProperties, HTMLAttributes } from 'react';\nimport { MenuItem } from '../MenuItem';\nimport { MenuItemContent } from './MenuItemContent';\n\nconst listStyle: CSSProperties = { listStyle: 'none', margin: 0, padding: 0, color: 'var(--scene-text-color)' };\n\nconst markerStyle: CSSProperties = {\n    width: '1.75rem',\n    height: '1.75rem',\n    borderRadius: '50%',\n    border: '1px solid var(--scene-surface-border)',\n    background: 'var(--scene-surface-card)',\n    color: 'var(--scene-text-muted-color)',\n};\n\nconst reachedMarkerStyle: CSSProperties = {\n    ...markerStyle,\n    background: 'var(--scene-primary-color)',\n    borderColor: 'var(--scene-primary-color)',\n    color: 'var(--scene-primary-contrast-color)',\n};\n\nconst pendingStepStyle: CSSProperties = { color: 'var(--scene-text-muted-color)' };\n\n/**\n * The configuration {@link Steps} takes.\n */\nexport interface StepsProps extends HTMLAttributes<HTMLOListElement> {\n    /**\n     * The steps in the sequence, in order.\n     */\n    items?: MenuItem[];\n\n    /**\n     * The zero-based step the user is on. Everything before it counts as reached.\n     */\n    activeIndex?: number;\n}\n\n/**\n * A numbered horizontal indicator of where the user is in a sequence. Cratis-owned.\n *\n * This exists because PrimeReact 11 removed `primereact/steps` outright. `primereact/stepper` survives,\n * but it is not a replacement: a stepper owns the content of each step and drives moving between them,\n * whereas `steps` shows position and nothing else, next to whatever a screen chose to render itself. Scene\n * has both concepts and they are registered separately, so collapsing one into the other would silently\n * change what an authored screen means.\n *\n * It is an ordered list because that is what it is - a numbered sequence, read in order - and the step the\n * user is on is marked with `aria-current` rather than only with color, so the position is available to a\n * screen reader and not just to an eye.\n *\n * What it deliberately does not carry over from the v10 `Steps`: the indicator is read-only, so v10's\n * `readOnly={false}` mode where clicking a step jumped to it is gone, and with it the `onSelect` callback\n * and the internally held selection. A screen that wants navigable steps should hold the position itself\n * and render whatever control it wants to move between them. Item templates and the vertical layout are\n * not supported either.\n */\nexport function Steps({ items = [], activeIndex = 0, ...rest }: StepsProps) {\n    return (\n        <ol {...rest} className='flex items-center gap-4' style={listStyle}>\n            {items.map((item, index) => (\n                <li\n                    key={index}\n                    className='inline-flex items-center gap-2'\n                    style={index <= activeIndex ? undefined : pendingStepStyle}\n                    aria-current={index === activeIndex ? 'step' : undefined}>\n                    <span className='inline-flex items-center justify-center' aria-hidden='true' style={index <= activeIndex ? reachedMarkerStyle : markerStyle}>\n                        {index + 1}\n                    </span>\n                    <MenuItemContent item={item} />\n                </li>\n            ))}\n        </ol>\n    );\n}\n"],"names":["listStyle","margin","padding","color","markerStyle","width","height","borderRadius","border","background","reachedMarkerStyle","borderColor","pendingStepStyle","Steps","items","activeIndex","rest","_jsx","ol","className","style","map","item","index","_jsxs","li","undefined","aria-current","span","aria-hidden","MenuItemContent"],"mappings":";;;;;AAAA;AACA;AAMA,MAAMA,SAAAA,GAA2B;IAAEA,SAAAA,EAAW,MAAA;IAAQC,MAAAA,EAAQ,CAAA;IAAGC,OAAAA,EAAS,CAAA;IAAGC,KAAAA,EAAO;AAA0B,CAAA;AAE9G,MAAMC,WAAAA,GAA6B;IAC/BC,KAAAA,EAAO,SAAA;IACPC,MAAAA,EAAQ,SAAA;IACRC,YAAAA,EAAc,KAAA;IACdC,MAAAA,EAAQ,uCAAA;IACRC,UAAAA,EAAY,2BAAA;IACZN,KAAAA,EAAO;AACX,CAAA;AAEA,MAAMO,kBAAAA,GAAoC;AACtC,IAAA,GAAGN,WAAW;IACdK,UAAAA,EAAY,4BAAA;IACZE,WAAAA,EAAa,4BAAA;IACbR,KAAAA,EAAO;AACX,CAAA;AAEA,MAAMS,gBAAAA,GAAkC;IAAET,KAAAA,EAAO;AAAgC,CAAA;AAiBjF;;;;;;;;;;;;;;;;;;IAmBO,SAASU,KAAAA,CAAM,EAAEC,KAAAA,GAAQ,EAAE,EAAEC,WAAAA,GAAc,CAAC,EAAE,GAAGC,IAAAA,EAAkB,EAAA;AACtE,IAAA,qBACIC,cAAA,CAACC,IAAAA,EAAAA;AAAI,QAAA,GAAGF,IAAI;QAAEG,SAAAA,EAAU,yBAAA;QAA0BC,KAAAA,EAAOpB,SAAAA;AACpDc,QAAAA,QAAAA,EAAAA,KAAAA,CAAMO,GAAG,CAAC,CAACC,IAAAA,EAAMC,sBACdC,eAAA,CAACC,IAAAA,EAAAA;gBAEGN,SAAAA,EAAU,gCAAA;gBACVC,KAAAA,EAAOG,KAAAA,IAASR,cAAcW,SAAAA,GAAYd,gBAAAA;gBAC1Ce,cAAAA,EAAcJ,KAAAA,KAAUR,cAAc,MAAA,GAASW,SAAAA;;kCAC/CT,cAAA,CAACW,MAAAA,EAAAA;wBAAKT,SAAAA,EAAU,yCAAA;wBAA0CU,aAAAA,EAAY,MAAA;wBAAOT,KAAAA,EAAOG,KAAAA,IAASR,cAAcL,kBAAAA,GAAqBN,WAAAA;kCAC3HmB,KAAAA,GAAQ;;kCAEbN,cAAA,CAACa,+BAAAA,EAAAA;wBAAgBR,IAAAA,EAAMA;;;AAPlBC,aAAAA,EAAAA,KAAAA,CAAAA;;AAYzB;;;;"}

package/dist/cjs/menu/TabMenu.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var MenuItemAction = require('./MenuItemAction.js');
+
+const barStyle = {
+    borderBottom: '1px solid var(--scene-surface-border)',
+    color: 'var(--scene-text-color)'
+};
+const tabStyle = {
+    background: 'transparent',
+    border: 'none',
+    borderBottom: '2px solid transparent',
+    color: 'var(--scene-text-muted-color)',
+    cursor: 'pointer',
+    font: 'inherit',
+    textDecoration: 'none'
+};
+const selectedTabStyle = {
+    ...tabStyle,
+    borderBottomColor: 'var(--scene-primary-color)',
+    color: 'var(--scene-text-color)'
+};
+/**
+ * Tab-styled horizontal navigation between destinations. Cratis-owned.
+ *
+ * This exists because PrimeReact 11 removed `primereact/tabmenu` outright. `primereact/tabs` survives and
+ * was the obvious candidate to build on, but it was rejected on purpose: `Tabs.Tab` emits `role="tab"` and
+ * an `aria-controls` pointing at the tab panel it expects to sit beside, and a navigation bar has no
+ * panels. Adopting it would produce markup that announces panels which do not exist and references ids
+ * that resolve to nothing - a real accessibility defect traded for a little less code.
+ *
+ * So this is a `nav` holding links and buttons, with the current entry marked `aria-current`, which is the
+ * pattern the tabs look is imitating. The tab appearance is styling; the semantics are navigation, and
+ * they now agree.
+ *
+ * What it deliberately does not carry over from the v10 `TabMenu`: there is no roving-focus keyboard model
+ * with arrow keys moving between entries - the entries are ordinary links and buttons in the tab order -
+ * no scroll buttons when the entries overflow, no sliding active-bar animation, and no item templates. The
+ * selected entry is held here so the control responds in a preview, exactly as the v10 adapter did.
+ */ function TabMenu({ items = [], activeIndex = 0, ...rest }) {
+    const [selectedIndex, setSelectedIndex] = react.useState(activeIndex);
+    return /*#__PURE__*/ jsxRuntime.jsx("nav", {
+        ...rest,
+        className: "flex items-center gap-2",
+        style: barStyle,
+        children: items.map((item, index)=>/*#__PURE__*/ jsxRuntime.jsx(MenuItemAction.MenuItemAction, {
+                item: item,
+                current: index === selectedIndex,
+                className: "inline-flex items-center gap-2 p-3",
+                style: index === selectedIndex ? selectedTabStyle : tabStyle,
+                onActivate: ()=>setSelectedIndex(index)
+            }, index))
+    });
+}
+
+exports.TabMenu = TabMenu;
+//# sourceMappingURL=TabMenu.js.map

package/dist/cjs/menu/TabMenu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TabMenu.js","sources":["../../../menu/TabMenu.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 { CSSProperties, HTMLAttributes, useState } from 'react';\nimport { MenuItem } from '../MenuItem';\nimport { MenuItemAction } from './MenuItemAction';\n\nconst barStyle: CSSProperties = { borderBottom: '1px solid var(--scene-surface-border)', color: 'var(--scene-text-color)' };\n\nconst tabStyle: CSSProperties = {\n    background: 'transparent',\n    border: 'none',\n    borderBottom: '2px solid transparent',\n    color: 'var(--scene-text-muted-color)',\n    cursor: 'pointer',\n    font: 'inherit',\n    textDecoration: 'none',\n};\n\nconst selectedTabStyle: CSSProperties = { ...tabStyle, borderBottomColor: 'var(--scene-primary-color)', color: 'var(--scene-text-color)' };\n\n/**\n * The configuration {@link TabMenu} takes.\n */\nexport interface TabMenuProps extends HTMLAttributes<HTMLElement> {\n    /**\n     * The destinations to show, in order.\n     */\n    items?: MenuItem[];\n\n    /**\n     * The zero-based entry to start on.\n     */\n    activeIndex?: number;\n}\n\n/**\n * Tab-styled horizontal navigation between destinations. Cratis-owned.\n *\n * This exists because PrimeReact 11 removed `primereact/tabmenu` outright. `primereact/tabs` survives and\n * was the obvious candidate to build on, but it was rejected on purpose: `Tabs.Tab` emits `role=\"tab\"` and\n * an `aria-controls` pointing at the tab panel it expects to sit beside, and a navigation bar has no\n * panels. Adopting it would produce markup that announces panels which do not exist and references ids\n * that resolve to nothing - a real accessibility defect traded for a little less code.\n *\n * So this is a `nav` holding links and buttons, with the current entry marked `aria-current`, which is the\n * pattern the tabs look is imitating. The tab appearance is styling; the semantics are navigation, and\n * they now agree.\n *\n * What it deliberately does not carry over from the v10 `TabMenu`: there is no roving-focus keyboard model\n * with arrow keys moving between entries - the entries are ordinary links and buttons in the tab order -\n * no scroll buttons when the entries overflow, no sliding active-bar animation, and no item templates. The\n * selected entry is held here so the control responds in a preview, exactly as the v10 adapter did.\n */\nexport function TabMenu({ items = [], activeIndex = 0, ...rest }: TabMenuProps) {\n    const [selectedIndex, setSelectedIndex] = useState(activeIndex);\n\n    return (\n        <nav {...rest} className='flex items-center gap-2' style={barStyle}>\n            {items.map((item, index) => (\n                <MenuItemAction\n                    key={index}\n                    item={item}\n                    current={index === selectedIndex}\n                    className='inline-flex items-center gap-2 p-3'\n                    style={index === selectedIndex ? selectedTabStyle : tabStyle}\n                    onActivate={() => setSelectedIndex(index)}\n                />\n            ))}\n        </nav>\n    );\n}\n"],"names":["barStyle","borderBottom","color","tabStyle","background","border","cursor","font","textDecoration","selectedTabStyle","borderBottomColor","TabMenu","items","activeIndex","rest","selectedIndex","setSelectedIndex","useState","_jsx","nav","className","style","map","item","index","MenuItemAction","current","onActivate"],"mappings":";;;;;;AAOA,MAAMA,QAAAA,GAA0B;IAAEC,YAAAA,EAAc,uCAAA;IAAyCC,KAAAA,EAAO;AAA0B,CAAA;AAE1H,MAAMC,QAAAA,GAA0B;IAC5BC,UAAAA,EAAY,aAAA;IACZC,MAAAA,EAAQ,MAAA;IACRJ,YAAAA,EAAc,uBAAA;IACdC,KAAAA,EAAO,+BAAA;IACPI,MAAAA,EAAQ,SAAA;IACRC,IAAAA,EAAM,SAAA;IACNC,cAAAA,EAAgB;AACpB,CAAA;AAEA,MAAMC,gBAAAA,GAAkC;AAAE,IAAA,GAAGN,QAAQ;IAAEO,iBAAAA,EAAmB,4BAAA;IAA8BR,KAAAA,EAAO;AAA0B,CAAA;AAiBzI;;;;;;;;;;;;;;;;;IAkBO,SAASS,OAAAA,CAAQ,EAAEC,KAAAA,GAAQ,EAAE,EAAEC,WAAAA,GAAc,CAAC,EAAE,GAAGC,IAAAA,EAAoB,EAAA;AAC1E,IAAA,MAAM,CAACC,aAAAA,EAAeC,gBAAAA,CAAiB,GAAGC,cAAAA,CAASJ,WAAAA,CAAAA;AAEnD,IAAA,qBACIK,cAAA,CAACC,KAAAA,EAAAA;AAAK,QAAA,GAAGL,IAAI;QAAEM,SAAAA,EAAU,yBAAA;QAA0BC,KAAAA,EAAOrB,QAAAA;AACrDY,QAAAA,QAAAA,EAAAA,KAAAA,CAAMU,GAAG,CAAC,CAACC,IAAAA,EAAMC,sBACdN,cAAA,CAACO,6BAAAA,EAAAA;gBAEGF,IAAAA,EAAMA,IAAAA;AACNG,gBAAAA,OAAAA,EAASF,KAAAA,KAAUT,aAAAA;gBACnBK,SAAAA,EAAU,oCAAA;gBACVC,KAAAA,EAAOG,KAAAA,KAAUT,gBAAgBN,gBAAAA,GAAmBN,QAAAA;AACpDwB,gBAAAA,UAAAA,EAAY,IAAMX,gBAAAA,CAAiBQ,KAAAA;AAL9BA,aAAAA,EAAAA,KAAAA,CAAAA;;AAUzB;;;;"}