@cratis/scene.primereact 1.1.0 → 3.0.0

package/dist/esm/menu/PrimeBreadcrumb.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeBreadcrumb.js","sources":["../../../menu/PrimeBreadcrumb.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 { BreadCrumb } from 'primereact/breadcrumb';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:breadcrumb` component - the path to where the user currently is.\n *\n * The home entry is separate from the trail in PrimeReact's model, so it is read from its own `homeUrl`\n * property and always rendered as an icon.\n */\nexport function PrimeBreadcrumb({ element }: RegisteredComponentProps) {\n    return (\n        <BreadCrumb\n            data-scene-id={element.id}\n            model={menuItemsProperty(element, 'items')}\n            home={{ icon: 'pi pi-home', url: stringProperty(element, 'homeUrl', '/') }}\n        />\n    );\n}\n"],"names":["PrimeBreadcrumb","element","_jsx","BreadCrumb","data-scene-id","id","model","menuItemsProperty","home","icon","url","stringProperty"],"mappings":";;;;;AAQA;;;;;AAKC,IACM,SAASA,eAAAA,CAAgB,EAAEC,OAAO,EAA4B,EAAA;AACjE,IAAA,qBACIC,GAAA,CAACC,UAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA,CAAA;QAClCO,IAAAA,EAAM;YAAEC,IAAAA,EAAM,YAAA;YAAcC,GAAAA,EAAKC,cAAAA,CAAeV,SAAS,SAAA,EAAW,GAAA;AAAK;;AAGrF;;;;"}
+{"version":3,"file":"PrimeBreadcrumb.js","sources":["../../../menu/PrimeBreadcrumb.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 { Fragment, ReactNode } from 'react';\nimport { Breadcrumb } from 'primereact/breadcrumb';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { MenuItem } from '../MenuItem';\nimport { menuItemsProperty } from '../menuItems';\nimport { stringProperty } from '../properties';\nimport { MenuItemContent } from './MenuItemContent';\n\n/**\n * One entry in the trail, as the strongest thing the authored data supports.\n *\n * The three cases are genuinely different to assistive technology and only one of them is a link. Where\n * the user already is gets `Breadcrumb.Current`, which carries `aria-current=\"page\"` and is what tells a\n * screen reader the trail has ended - a trailing link says the opposite. An earlier entry that names a\n * target is a link. An earlier entry that names none is plain text, because an anchor with no `href` is\n * not focusable and only looks like a link.\n *\n * @param item The entry to render.\n * @param current Whether this is the last entry, and so where the user is now.\n * @returns The rendered entry.\n */\nfunction breadcrumbEntry(item: MenuItem, current: boolean): ReactNode {\n    if (current) {\n        return (\n            <Breadcrumb.Current>\n                <MenuItemContent item={item} />\n            </Breadcrumb.Current>\n        );\n    }\n\n    if (item.url === undefined) return <MenuItemContent item={item} />;\n\n    return (\n        <Breadcrumb.Link href={item.url}>\n            <MenuItemContent item={item} />\n        </Breadcrumb.Link>\n    );\n}\n\n/**\n * The `PrimeReact:breadcrumb` component - the path to where the user currently is.\n *\n * The home entry is separate from the trail in the authored model, so it is read from its own `homeUrl`\n * property and always rendered as an icon.\n *\n * PrimeReact 11 replaced the single `BreadCrumb` component and its `model`/`home` props with a namespace\n * of parts, so the trail is assembled here. The parts are worth assembling rather than working around:\n * the root is a `nav` carrying an accessible name, the list is an ordered list, and every separator is\n * marked presentational so it is never read out as part of the path. The old `model` prop produced all of\n * that too, but only because the component decided it - none of it is something a hand-rolled trail would\n * reliably reproduce.\n */\nexport function PrimeBreadcrumb({ element }: RegisteredComponentProps) {\n    const items = menuItemsProperty(element, 'items');\n\n    return (\n        <Breadcrumb.Root data-scene-id={element.id}>\n            <Breadcrumb.List>\n                <Breadcrumb.Item>\n                    <Breadcrumb.Link href={stringProperty(element, 'homeUrl', '/')} aria-label='Home'>\n                        <i className='pi pi-home' aria-hidden='true' />\n                    </Breadcrumb.Link>\n                </Breadcrumb.Item>\n                {items.map((item, index) => (\n                    <Fragment key={index}>\n                        <Breadcrumb.Separator>\n                            <i className='pi pi-angle-right' aria-hidden='true' />\n                        </Breadcrumb.Separator>\n                        <Breadcrumb.Item>{breadcrumbEntry(item, index === items.length - 1)}</Breadcrumb.Item>\n                    </Fragment>\n                ))}\n            </Breadcrumb.List>\n        </Breadcrumb.Root>\n    );\n}\n"],"names":["breadcrumbEntry","item","current","_jsx","Breadcrumb","Current","MenuItemContent","url","undefined","Link","href","PrimeBreadcrumb","element","items","menuItemsProperty","Root","data-scene-id","id","_jsxs","List","Item","stringProperty","aria-label","i","className","aria-hidden","map","index","Fragment","Separator","length"],"mappings":";;;;;;;AAWA;;;;;;;;;;;;AAYC,IACD,SAASA,eAAAA,CAAgBC,IAAc,EAAEC,OAAgB,EAAA;AACrD,IAAA,IAAIA,OAAAA,EAAS;QACT,qBACIC,GAAA,CAACC,WAAWC,OAAO,EAAA;AACf,YAAA,QAAA,gBAAAF,GAAA,CAACG,eAAAA,EAAAA;gBAAgBL,IAAAA,EAAMA;;;AAGnC,IAAA;AAEA,IAAA,IAAIA,IAAAA,CAAKM,GAAG,KAAKC,SAAAA,EAAW,qBAAOL,GAAA,CAACG,eAAAA,EAAAA;QAAgBL,IAAAA,EAAMA;;IAE1D,qBACIE,GAAA,CAACC,WAAWK,IAAI,EAAA;AAACC,QAAAA,IAAAA,EAAMT,KAAKM,GAAG;AAC3B,QAAA,QAAA,gBAAAJ,GAAA,CAACG,eAAAA,EAAAA;YAAgBL,IAAAA,EAAMA;;;AAGnC;AAEA;;;;;;;;;;;;AAYC,IACM,SAASU,eAAAA,CAAgB,EAAEC,OAAO,EAA4B,EAAA;IACjE,MAAMC,KAAAA,GAAQC,kBAAkBF,OAAAA,EAAS,OAAA,CAAA;IAEzC,qBACIT,GAAA,CAACC,WAAWW,IAAI,EAAA;AAACC,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;gCACtCC,IAAA,CAACd,WAAWe,IAAI,EAAA;;AACZ,8BAAAhB,GAAA,CAACC,WAAWgB,IAAI,EAAA;4CACZjB,GAAA,CAACC,WAAWK,IAAI,EAAA;wBAACC,IAAAA,EAAMW,cAAAA,CAAeT,SAAS,SAAA,EAAW,GAAA,CAAA;wBAAMU,YAAAA,EAAW,MAAA;AACvE,wBAAA,QAAA,gBAAAnB,GAAA,CAACoB,GAAAA,EAAAA;4BAAEC,SAAAA,EAAU,YAAA;4BAAaC,aAAAA,EAAY;;;;AAG7CZ,gBAAAA,KAAAA,CAAMa,GAAG,CAAC,CAACzB,IAAAA,EAAM0B,sBACdT,IAAA,CAACU,QAAAA,EAAAA;;AACG,0CAAAzB,GAAA,CAACC,WAAWyB,SAAS,EAAA;AACjB,gCAAA,QAAA,gBAAA1B,GAAA,CAACoB,GAAAA,EAAAA;oCAAEC,SAAAA,EAAU,mBAAA;oCAAoBC,aAAAA,EAAY;;;AAEjD,0CAAAtB,GAAA,CAACC,WAAWgB,IAAI,EAAA;AAAEpB,gCAAAA,QAAAA,EAAAA,eAAAA,CAAgBC,IAAAA,EAAM0B,KAAAA,KAAUd,KAAAA,CAAMiB,MAAM,GAAG,CAAA;;;AAJtDH,qBAAAA,EAAAA,KAAAA,CAAAA;;;;AAUnC;;;;"}

package/dist/esm/menu/PrimeContextMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeContextMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeContextMenu.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAW/D,wBAAgB,gBAAgB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAQ5E"}
+{"version":3,"file":"PrimeContextMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeContextMenu.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAqB/D,wBAAgB,gBAAgB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAiC5E"}

package/dist/esm/menu/PrimeContextMenu.js

@@ -1,27 +1,51 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
-import { useRef } from 'react';
 import { ContextMenu } from 'primereact/contextmenu';
 import { menuItemsProperty } from '../menuItems.js';
 import { stringProperty } from '../properties.js';
+import { MenuItemContent } from './MenuItemContent.js';
 
 /**
  * The `PrimeReact:contextMenu` component - commands revealed by right-clicking a region.
  *
- * ContextMenu is opened by a caller reacting to a context-menu event, so the adapter renders the region
- * that owns that event as well. Without it the menu could never be opened and the element would render
- * as nothing at all.
+ * The adapter renders the region that owns the context-menu event as well as the menu itself. Without it
+ * the menu could never be opened and the element would render as nothing at all.
+ *
+ * What changed in PrimeReact 11 is who owns that event. In v10 the menu was one component and the caller
+ * had to hold a ref to it and call `show(event)` from its own `onContextMenu` handler. In v11
+ * `ContextMenu.Trigger` is a part that already carries the handler, the `aria-haspopup` and the expanded
+ * state, so the ref and the hand-written handler are both gone - the region is now declared as the
+ * trigger rather than wired to the menu after the fact.
+ *
+ * The overlay is spelled out as portal, positioner and popup because those are separate parts now. That is
+ * not ceremony: the positioner is what keeps the menu on screen near the pointer, and it renders nothing
+ * at all until the menu is actually open, which is what makes an unopened context menu cost nothing.
  */ function PrimeContextMenu({ element, slots }) {
-    const menu = useRef(null);
-    return /*#__PURE__*/ jsxs("div", {
+    const items = menuItemsProperty(element, 'items');
+    return /*#__PURE__*/ jsxs(ContextMenu.Root, {
         "data-scene-id": element.id,
-        onContextMenu: (event)=>menu.current?.show(event),
         children: [
-            /*#__PURE__*/ jsx(ContextMenu, {
-                ref: menu,
-                model: menuItemsProperty(element, 'items')
+            /*#__PURE__*/ jsx(ContextMenu.Trigger, {
+                children: slots.content?.length ? slots.content : /*#__PURE__*/ jsx("span", {
+                    children: stringProperty(element, 'label', 'Right-click here')
+                })
             }),
-            slots.content?.length ? slots.content : /*#__PURE__*/ jsx("span", {
-                children: stringProperty(element, 'label', 'Right-click here')
+            /*#__PURE__*/ jsx(ContextMenu.Portal, {
+                children: /*#__PURE__*/ jsx(ContextMenu.Positioner, {
+                    children: /*#__PURE__*/ jsx(ContextMenu.Popup, {
+                        children: /*#__PURE__*/ jsx(ContextMenu.List, {
+                            children: items.map((item, index)=>item.separator === true ? /*#__PURE__*/ jsx(ContextMenu.Separator, {}, index) : /*#__PURE__*/ jsx(ContextMenu.Item, {
+                                    value: `${index}`,
+                                    as: item.url === undefined ? 'div' : 'a',
+                                    href: item.url,
+                                    disabled: item.disabled,
+                                    onSelect: ()=>item.command?.(),
+                                    children: /*#__PURE__*/ jsx(MenuItemContent, {
+                                        item: item
+                                    })
+                                }, index))
+                        })
+                    })
+                })
             })
         ]
     });

package/dist/esm/menu/PrimeContextMenu.js.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeContextMenu.js","sources":["../../../menu/PrimeContextMenu.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 { useRef } from 'react';\nimport { ContextMenu } from 'primereact/contextmenu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:contextMenu` component - commands revealed by right-clicking a region.\n *\n * ContextMenu is opened by a caller reacting to a context-menu event, so the adapter renders the region\n * that owns that event as well. Without it the menu could never be opened and the element would render\n * as nothing at all.\n */\nexport function PrimeContextMenu({ element, slots }: RegisteredComponentProps) {\n    const menu = useRef<ContextMenu>(null);\n    return (\n        <div data-scene-id={element.id} onContextMenu={(event) => menu.current?.show(event)}>\n            <ContextMenu ref={menu} model={menuItemsProperty(element, 'items')} />\n            {slots.content?.length ? slots.content : <span>{stringProperty(element, 'label', 'Right-click here')}</span>}\n        </div>\n    );\n}\n"],"names":["PrimeContextMenu","element","slots","menu","useRef","_jsxs","div","data-scene-id","id","onContextMenu","event","current","show","_jsx","ContextMenu","ref","model","menuItemsProperty","content","length","span","stringProperty"],"mappings":";;;;;;AASA;;;;;;AAMC,IACM,SAASA,gBAAAA,CAAiB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACzE,IAAA,MAAMC,OAAOC,MAAAA,CAAoB,IAAA,CAAA;AACjC,IAAA,qBACIC,IAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeN,QAAQO,EAAE;AAAEC,QAAAA,aAAAA,EAAe,CAACC,KAAAA,GAAUP,IAAAA,CAAKQ,OAAO,EAAEC,IAAAA,CAAKF,KAAAA,CAAAA;;0BACzEG,GAAA,CAACC,WAAAA,EAAAA;gBAAYC,GAAAA,EAAKZ,IAAAA;AAAMa,gBAAAA,KAAAA,EAAOC,kBAAkBhB,OAAAA,EAAS,OAAA;;AACzDC,YAAAA,KAAAA,CAAMgB,OAAO,EAAEC,MAAAA,GAASjB,KAAAA,CAAMgB,OAAO,iBAAGL,GAAA,CAACO,MAAAA,EAAAA;AAAMC,gBAAAA,QAAAA,EAAAA,cAAAA,CAAepB,SAAS,OAAA,EAAS,kBAAA;;;;AAG7F;;;;"}
+{"version":3,"file":"PrimeContextMenu.js","sources":["../../../menu/PrimeContextMenu.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 { ContextMenu } from 'primereact/contextmenu';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { menuItemsProperty } from '../menuItems';\nimport { stringProperty } from '../properties';\nimport { MenuItemContent } from './MenuItemContent';\n\n/**\n * The `PrimeReact:contextMenu` component - commands revealed by right-clicking a region.\n *\n * The adapter renders the region that owns the context-menu event as well as the menu itself. Without it\n * the menu could never be opened and the element would render as nothing at all.\n *\n * What changed in PrimeReact 11 is who owns that event. In v10 the menu was one component and the caller\n * had to hold a ref to it and call `show(event)` from its own `onContextMenu` handler. In v11\n * `ContextMenu.Trigger` is a part that already carries the handler, the `aria-haspopup` and the expanded\n * state, so the ref and the hand-written handler are both gone - the region is now declared as the\n * trigger rather than wired to the menu after the fact.\n *\n * The overlay is spelled out as portal, positioner and popup because those are separate parts now. That is\n * not ceremony: the positioner is what keeps the menu on screen near the pointer, and it renders nothing\n * at all until the menu is actually open, which is what makes an unopened context menu cost nothing.\n */\nexport function PrimeContextMenu({ element, slots }: RegisteredComponentProps) {\n    const items = menuItemsProperty(element, 'items');\n\n    return (\n        <ContextMenu.Root data-scene-id={element.id}>\n            <ContextMenu.Trigger>\n                {slots.content?.length ? slots.content : <span>{stringProperty(element, 'label', 'Right-click here')}</span>}\n            </ContextMenu.Trigger>\n            <ContextMenu.Portal>\n                <ContextMenu.Positioner>\n                    <ContextMenu.Popup>\n                        <ContextMenu.List>\n                            {items.map((item, index) =>\n                                item.separator === true ? (\n                                    <ContextMenu.Separator key={index} />\n                                ) : (\n                                    <ContextMenu.Item\n                                        key={index}\n                                        value={`${index}`}\n                                        as={item.url === undefined ? 'div' : 'a'}\n                                        href={item.url}\n                                        disabled={item.disabled}\n                                        onSelect={() => item.command?.()}>\n                                        <MenuItemContent item={item} />\n                                    </ContextMenu.Item>\n                                )\n                            )}\n                        </ContextMenu.List>\n                    </ContextMenu.Popup>\n                </ContextMenu.Positioner>\n            </ContextMenu.Portal>\n        </ContextMenu.Root>\n    );\n}\n"],"names":["PrimeContextMenu","element","slots","items","menuItemsProperty","_jsxs","ContextMenu","Root","data-scene-id","id","_jsx","Trigger","content","length","span","stringProperty","Portal","Positioner","Popup","List","map","item","index","separator","Separator","Item","value","as","url","undefined","href","disabled","onSelect","command","MenuItemContent"],"mappings":";;;;;;AASA;;;;;;;;;;;;;;;AAeC,IACM,SAASA,gBAAAA,CAAiB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IACzE,MAAMC,KAAAA,GAAQC,kBAAkBH,OAAAA,EAAS,OAAA,CAAA;IAEzC,qBACII,IAAA,CAACC,YAAYC,IAAI,EAAA;AAACC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;;AACvC,0BAAAC,GAAA,CAACJ,YAAYK,OAAO,EAAA;AACfT,gBAAAA,QAAAA,EAAAA,KAAAA,CAAMU,OAAO,EAAEC,MAAAA,GAASX,KAAAA,CAAMU,OAAO,iBAAGF,GAAA,CAACI,MAAAA,EAAAA;AAAMC,oBAAAA,QAAAA,EAAAA,cAAAA,CAAed,SAAS,OAAA,EAAS,kBAAA;;;AAErF,0BAAAS,GAAA,CAACJ,YAAYU,MAAM,EAAA;wCACfN,GAAA,CAACJ,YAAYW,UAAU,EAAA;4CACnBP,GAAA,CAACJ,YAAYY,KAAK,EAAA;gDACdR,GAAA,CAACJ,YAAYa,IAAI,EAAA;AACZhB,4BAAAA,QAAAA,EAAAA,KAAAA,CAAMiB,GAAG,CAAC,CAACC,IAAAA,EAAMC,KAAAA,GACdD,KAAKE,SAAS,KAAK,IAAA,iBACfb,GAAA,CAACJ,YAAYkB,SAAS,EAAA,EAAA,EAAMF,KAAAA,CAAAA,iBAE5BZ,GAAA,CAACJ,YAAYmB,IAAI,EAAA;AAEbC,oCAAAA,KAAAA,EAAO,GAAGJ,KAAAA,CAAAA,CAAO;AACjBK,oCAAAA,EAAAA,EAAIN,IAAAA,CAAKO,GAAG,KAAKC,SAAAA,GAAY,KAAA,GAAQ,GAAA;AACrCC,oCAAAA,IAAAA,EAAMT,KAAKO,GAAG;AACdG,oCAAAA,QAAAA,EAAUV,KAAKU,QAAQ;oCACvBC,QAAAA,EAAU,IAAMX,KAAKY,OAAO,IAAA;AAC5B,oCAAA,QAAA,gBAAAvB,GAAA,CAACwB,eAAAA,EAAAA;wCAAgBb,IAAAA,EAAMA;;AANlBC,iCAAAA,EAAAA,KAAAA,CAAAA;;;;;;;AAgB7C;;;;"}

package/dist/esm/menu/PrimeDock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeDock.d.ts","sourceRoot":"","sources":["../../../menu/PrimeDock.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAY/D,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAM9D"}
+{"version":3,"file":"PrimeDock.d.ts","sourceRoot":"","sources":["../../../menu/PrimeDock.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAwC/D,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAM9D"}

package/dist/esm/menu/PrimeDock.js

@@ -1,22 +1,49 @@
 import { jsx } from 'react/jsx-runtime';
-import { Dock } from 'primereact/dock';
 import { menuItemsProperty } from '../menuItems.js';
 import { stringProperty } from '../properties.js';
+import { Dock } from './Dock.js';
+import { DockPosition } from './DockPosition.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:dock` component - a macOS-style dock of magnifying icons.
+ * Narrows an authored `position` onto the edges a dock can actually be anchored to.
  *
- * Dock positions itself absolutely against its nearest positioned ancestor, so it is wrapped in a sized
- * relative box; dropped straight into a Scene tree it would otherwise pin itself to the page.
+ * A screen's properties are authored data rather than compiler-checked values, so an unrecognized edge is
+ * an ordinary thing to encounter. Falling back to the bottom edge - the dock's own default - keeps a
+ * mistyped property behaving exactly like an absent one, which is the rule every reader in this package
+ * follows.
  *
- * In PrimeReact 11 this component is removed with no direct replacement.
+ * @param value The authored position.
+ * @returns The matching edge, or the bottom edge when the value names none.
+ */ function dockPosition(value) {
+    switch(value){
+        case DockPosition.Top:
+            return DockPosition.Top;
+        case DockPosition.Left:
+            return DockPosition.Left;
+        case DockPosition.Right:
+            return DockPosition.Right;
+        default:
+            return DockPosition.Bottom;
+    }
+}
+/**
+ * The `PrimeReact:dock` component - a strip of icons anchored to one edge.
+ *
+ * PrimeReact 11 removed `dock` with nothing to replace it, so what this adapts is Scene's own
+ * {@link Dock}. The magnifying effect that made v10's dock recognizable is not part of the replacement;
+ * what a screen actually depends on is a row of icon commands pinned to an edge, and that is what remains.
+ *
+ * A dock positions itself absolutely against its nearest positioned ancestor, so it is wrapped in a sized
+ * relative box here; dropped straight into a Scene tree it would otherwise pin itself to the page.
  */ function PrimeDock({ element }) {
     return /*#__PURE__*/ jsx("div", {
         "data-scene-id": element.id,
         className: "relative h-40 w-full",
         children: /*#__PURE__*/ jsx(Dock, {
-            model: menuItemsProperty(element, 'items'),
-            position: stringProperty(element, 'position', 'bottom')
+            items: menuItemsProperty(element, 'items'),
+            position: dockPosition(stringProperty(element, 'position', DockPosition.Bottom))
         })
     });
 }

package/dist/esm/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,GAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;QAAEC,SAAAA,EAAU,sBAAA;AACtC,QAAA,QAAA,gBAAAJ,GAAA,CAACK,IAAAA,EAAAA;AAAKC,YAAAA,KAAAA,EAAOC,kBAAkBR,OAAAA,EAAS,OAAA,CAAA;YAAUS,QAAAA,EAAUC,cAAAA,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,aAAaC,GAAG;AACjB,YAAA,OAAOD,aAAaC,GAAG;AAC3B,QAAA,KAAKD,aAAaE,IAAI;AAClB,YAAA,OAAOF,aAAaE,IAAI;AAC5B,QAAA,KAAKF,aAAaG,KAAK;AACnB,YAAA,OAAOH,aAAaG,KAAK;AAC7B,QAAA;AACI,YAAA,OAAOH,aAAaI,MAAM;AAClC;AACJ;AAEA;;;;;;;;;AASC,IACM,SAASC,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;AAC3D,IAAA,qBACIC,GAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;QAAEC,SAAAA,EAAU,sBAAA;AACtC,QAAA,QAAA,gBAAAJ,GAAA,CAACK,IAAAA,EAAAA;AAAKC,YAAAA,KAAAA,EAAOC,kBAAkBR,OAAAA,EAAS,OAAA,CAAA;AAAUS,YAAAA,QAAAA,EAAUjB,YAAAA,CAAakB,cAAAA,CAAeV,OAAAA,EAAS,UAAA,EAAYN,aAAaI,MAAM,CAAA;;;AAG5I;;;;"}

package/dist/esm/menu/PrimeMegaMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeMegaMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeMegaMenu.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAW/D,wBAAgB,aAAa,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAQlE"}
+{"version":3,"file":"PrimeMegaMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeMegaMenu.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAe/D,wBAAgB,aAAa,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAElE"}

package/dist/esm/menu/PrimeMegaMenu.js

@@ -1,19 +1,23 @@
 import { jsx } from 'react/jsx-runtime';
-import { MegaMenu } from 'primereact/megamenu';
 import { menuItemsProperty } from '../menuItems.js';
-import { stringProperty } from '../properties.js';
+import { MegaMenu } from './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__*/ jsx(MegaMenu, {
         "data-scene-id": element.id,
-        model: menuItemsProperty(element, 'items'),
-        orientation: stringProperty(element, 'orientation', 'horizontal')
+        items: menuItemsProperty(element, 'items')
     });
 }
 

package/dist/esm/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,GAAA,CAACC,QAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA,CAAA;QAClCO,WAAAA,EAAaC,cAAAA,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,GAAA,CAACC,QAAAA,EAAAA;AAASC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA;;AAClF;;;;"}

package/dist/esm/menu/PrimeMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeMenu.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAM/D,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAE9D"}
+{"version":3,"file":"PrimeMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeMenu.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AA8C/D,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAwB9D"}

package/dist/esm/menu/PrimeMenu.js

@@ -1,13 +1,69 @@
-import { jsx } from 'react/jsx-runtime';
+import { jsx, jsxs } from 'react/jsx-runtime';
 import { Menu } from 'primereact/menu';
 import { menuItemsProperty } from '../menuItems.js';
+import { MenuItemContent } from './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__*/ jsx(Menu.Item, {
+        value: value,
+        as: item.url === undefined ? 'div' : 'a',
+        href: item.url,
+        disabled: item.disabled,
+        onSelect: ()=>item.command?.(),
+        children: /*#__PURE__*/ jsx(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__*/ jsx(Menu, {
+    const items = menuItemsProperty(element, 'items');
+    return /*#__PURE__*/ jsx(Menu.Root, {
+        as: "div",
         "data-scene-id": element.id,
-        model: menuItemsProperty(element, 'items')
+        children: /*#__PURE__*/ jsx(Menu.List, {
+            children: items.map((item, index)=>{
+                if (item.separator === true) return /*#__PURE__*/ jsx(Menu.Separator, {}, index);
+                const children = item.items ?? [];
+                if (children.length === 0) return menuEntry(item, `${index}`);
+                return /*#__PURE__*/ jsxs(Menu.Group, {
+                    children: [
+                        /*#__PURE__*/ jsx(Menu.Label, {
+                            children: /*#__PURE__*/ jsx(MenuItemContent, {
+                                item: item
+                            })
+                        }),
+                        children.map((child, childIndex)=>menuEntry(child, `${index}-${childIndex}`))
+                    ]
+                }, index);
+            })
+        })
     });
 }
 

package/dist/esm/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,GAAA,CAACC,IAAAA,EAAAA;AAAKC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,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,GAAA,CAACC,KAAKC,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,GAAA,CAACU,eAAAA,EAAAA;YAAgBZ,IAAAA,EAAMA;;AANlBC,KAAAA,EAAAA,KAAAA,CAAAA;AASjB;AAEA;;;;;;;;;;;;;;;AAeC,IACM,SAASY,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;IAC3D,MAAMC,KAAAA,GAAQC,kBAAkBF,OAAAA,EAAS,OAAA,CAAA;IAEzC,qBACIZ,GAAA,CAACC,KAAKc,IAAI,EAAA;QAACZ,EAAAA,EAAG,KAAA;AAAMa,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;gCACzCjB,GAAA,CAACC,KAAKiB,IAAI,EAAA;sBACLL,KAAAA,CAAMM,GAAG,CAAC,CAACrB,IAAAA,EAAMsB,KAAAA,GAAAA;gBACd,IAAItB,IAAAA,CAAKuB,SAAS,KAAK,IAAA,EAAM,qBAAOrB,GAAA,CAACC,IAAAA,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,IAAA,CAACxB,KAAKyB,KAAK,EAAA;;AACP,sCAAA1B,GAAA,CAACC,KAAK0B,KAAK,EAAA;AACP,4BAAA,QAAA,gBAAA3B,GAAA,CAACU,eAAAA,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/esm/menu/PrimeMenubar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeMenubar.d.ts","sourceRoot":"","sources":["../../../menu/PrimeMenubar.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAS/D,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAExE"}
+{"version":3,"file":"PrimeMenubar.d.ts","sourceRoot":"","sources":["../../../menu/PrimeMenubar.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAe/D,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAExE"}

package/dist/esm/menu/PrimeMenubar.js

@@ -1,16 +1,23 @@
 import { jsx } from 'react/jsx-runtime';
-import { Menubar } from 'primereact/menubar';
 import { menuItemsProperty } from '../menuItems.js';
+import { Menubar } from './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__*/ jsx(Menubar, {
         "data-scene-id": element.id,
-        model: menuItemsProperty(element, 'items'),
+        items: menuItemsProperty(element, 'items'),
         start: slots.start,
         end: slots.end
     });

package/dist/esm/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,GAAA,CAACC,OAAAA,EAAAA;AAAQC,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBP,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,GAAA,CAACC,OAAAA,EAAAA;AAAQC,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBP,OAAAA,EAAS,OAAA,CAAA;AAAUQ,QAAAA,KAAAA,EAAOP,MAAMO,KAAK;AAAEC,QAAAA,GAAAA,EAAKR,MAAMQ;;AAC1H;;;;"}

package/dist/esm/menu/PrimePanelMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimePanelMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimePanelMenu.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAS/D,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAInE"}
+{"version":3,"file":"PrimePanelMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimePanelMenu.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAa/D,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAEnE"}

package/dist/esm/menu/PrimePanelMenu.js

@@ -1,16 +1,21 @@
 import { jsx } from 'react/jsx-runtime';
-import { PanelMenu } from 'primereact/panelmenu';
 import { menuItemsProperty } from '../menuItems.js';
 import { booleanProperty } from '../properties.js';
+import { PanelMenu } from './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__*/ jsx(PanelMenu, {
         "data-scene-id": element.id,
-        model: menuItemsProperty(element, 'items'),
+        items: menuItemsProperty(element, 'items'),
         multiple: booleanProperty(element, 'multiple', false)
     });
 }

package/dist/esm/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,GAAA,CAACC,SAAAA,EAAAA;AAAUC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,QAAAA,EAAUC,eAAAA,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,GAAA,CAACC,SAAAA,EAAAA;AAAUC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,QAAAA,EAAUC,eAAAA,CAAgBR,SAAS,UAAA,EAAY,KAAA;;AAC5I;;;;"}

package/dist/esm/menu/PrimeSteps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeSteps.d.ts","sourceRoot":"","sources":["../../../menu/PrimeSteps.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAU/D,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAW/D"}
+{"version":3,"file":"PrimeSteps.d.ts","sourceRoot":"","sources":["../../../menu/PrimeSteps.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAmB/D,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAE/D"}

package/dist/esm/menu/PrimeSteps.js

@@ -1,22 +1,28 @@
 import { jsx } from 'react/jsx-runtime';
-import { useState } from 'react';
-import { Steps } from 'primereact/steps';
 import { menuItemsProperty } from '../menuItems.js';
-import { numberProperty, booleanProperty } from '../properties.js';
+import { numberProperty } from '../properties.js';
+import { Steps } from './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] = useState(numberProperty(element, 'activeIndex', 0));
     return /*#__PURE__*/ jsx(Steps, {
         "data-scene-id": element.id,
-        model: menuItemsProperty(element, 'items'),
-        activeIndex: activeIndex,
-        readOnly: booleanProperty(element, 'readOnly', false),
-        onSelect: (event)=>setActiveIndex(event.index)
+        items: menuItemsProperty(element, 'items'),
+        activeIndex: numberProperty(element, 'activeIndex', 0)
     });
 }
 

package/dist/esm/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,QAAAA,CAASC,cAAAA,CAAeJ,SAAS,aAAA,EAAe,CAAA,CAAA,CAAA;AACtF,IAAA,qBACIK,GAAA,CAACC,KAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,kBAAkBV,OAAAA,EAAS,OAAA,CAAA;QAClCC,WAAAA,EAAaA,WAAAA;QACbU,QAAAA,EAAUC,eAAAA,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,GAAA,CAACC,KAAAA,EAAAA;AAAMC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,WAAAA,EAAaC,cAAAA,CAAeR,SAAS,aAAA,EAAe,CAAA;;AAC7I;;;;"}

package/dist/esm/menu/PrimeTabMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeTabMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeTabMenu.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAW/D,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAUjE"}
+{"version":3,"file":"PrimeTabMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeTabMenu.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAgB/D,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAEjE"}

package/dist/esm/menu/PrimeTabMenu.js

@@ -1,22 +1,25 @@
 import { jsx } from 'react/jsx-runtime';
-import { useState } from 'react';
-import { TabMenu } from 'primereact/tabmenu';
 import { menuItemsProperty } from '../menuItems.js';
 import { numberProperty } from '../properties.js';
+import { TabMenu } from './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] = useState(numberProperty(element, 'activeIndex', 0));
     return /*#__PURE__*/ jsx(TabMenu, {
         "data-scene-id": element.id,
-        model: menuItemsProperty(element, 'items'),
-        activeIndex: activeIndex,
-        onTabChange: (event)=>setActiveIndex(event.index)
+        items: menuItemsProperty(element, 'items'),
+        activeIndex: numberProperty(element, 'activeIndex', 0)
     });
 }
 

package/dist/esm/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,QAAAA,CAASC,cAAAA,CAAeJ,SAAS,aAAA,EAAe,CAAA,CAAA,CAAA;AACtF,IAAA,qBACIK,GAAA,CAACC,OAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,kBAAkBV,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,GAAA,CAACC,OAAAA,EAAAA;AAAQC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA,CAAA;QAAUO,WAAAA,EAAaC,cAAAA,CAAeR,SAAS,aAAA,EAAe,CAAA;;AAC/I;;;;"}

package/dist/esm/menu/PrimeTieredMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrimeTieredMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeTieredMenu.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAM/D,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAEpE"}
+{"version":3,"file":"PrimeTieredMenu.d.ts","sourceRoot":"","sources":["../../../menu/PrimeTieredMenu.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAW/D,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAEpE"}

package/dist/esm/menu/PrimeTieredMenu.js

@@ -1,13 +1,19 @@
 import { jsx } from 'react/jsx-runtime';
-import { TieredMenu } from 'primereact/tieredmenu';
 import { menuItemsProperty } from '../menuItems.js';
+import { TieredMenu } from './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__*/ jsx(TieredMenu, {
         "data-scene-id": element.id,
-        model: menuItemsProperty(element, 'items')
+        items: menuItemsProperty(element, 'items')
     });
 }
 

package/dist/esm/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,GAAA,CAACC,UAAAA,EAAAA;AAAWC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,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,GAAA,CAACC,UAAAA,EAAAA;AAAWC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,kBAAkBN,OAAAA,EAAS,OAAA;;AACpF;;;;"}