@cratis/scene.react 3.7.0 → 4.0.0

package/dist/esm/for_useInteractions/when_clicking_an_element_that_executes_a_command.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { InteractionActionKind, InteractionTriggerKind, NotificationLevel } from '@cratis/scene.model';
+import { InteractionScope, useInteractions } from '../interactions';
+const calls = [];
+const dispatcher = {
+    async executeCommand(command, args) {
+        calls.push(`executeCommand:${command}:${JSON.stringify(args)}`);
+        return { isSuccess: true };
+    },
+    navigate: (screenName) => { calls.push(`navigate:${screenName}`); },
+    navigateBack: () => { calls.push('navigateBack'); },
+    openDialog: async () => { calls.push('openDialog'); return { isConfirmed: true }; },
+    closeDialog: () => { calls.push('closeDialog'); },
+    refreshQuery: async (query) => { calls.push(`refreshQuery:${query}`); },
+    setState: (target) => { calls.push(`setState:${target}`); },
+    notify: (level, message) => { calls.push(`notify:${level}:${message}`); },
+    confirm: async () => { calls.push('confirm'); return true; },
+    raise: async (trigger) => { calls.push(`raise:${trigger}`); },
+};
+const context = { resolve: binding => `<${binding.path}>` };
+const cancelOnClick = {
+    name: 'CancelInvoice',
+    bindings: [
+        {
+            trigger: { kind: InteractionTriggerKind.Click },
+            actions: [
+                {
+                    kind: InteractionActionKind.ExecuteCommand,
+                    command: 'CancelInvoice',
+                    arguments: [{ name: 'invoiceId', value: { path: 'item.invoiceId' } }],
+                    onSuccess: [{ kind: InteractionActionKind.RefreshQuery, query: 'Invoices' }],
+                },
+            ],
+        },
+    ],
+};
+function Button({ behaviors }) {
+    const handlers = useInteractions('element', behaviors);
+    return _jsx("button", { type: "button", ...handlers, children: "Cancel" });
+}
+function renderInScope(behaviors) {
+    return render(_jsx(InteractionScope, { dispatcher: dispatcher, context: context, attachments: [], children: _jsx(Button, { behaviors: behaviors }) }));
+}
+describe('when clicking an element that executes a command', () => {
+    beforeEach(() => { calls.length = 0; });
+    it('should execute the command the document declared', async () => {
+        renderInScope([cancelOnClick]);
+        await userEvent.click(screen.getByRole('button'));
+        calls.should.eql(['executeCommand:CancelInvoice:{"invoiceId":"<item.invoiceId>"}', 'refreshQuery:Invoices']);
+    });
+    it('should not make an element interactive when nothing is attached', async () => {
+        renderInScope();
+        await userEvent.click(screen.getByRole('button'));
+        calls.should.have.lengthOf(0);
+    });
+    it('should attach no handler for a trigger the document does not use', async () => {
+        renderInScope([cancelOnClick]);
+        await userEvent.dblClick(screen.getByRole('button'));
+        calls.filter(call => call.startsWith('executeCommand')).should.have.lengthOf(2);
+    });
+    it('should run a behavior attached further out as well as its own', async () => {
+        render(_jsx(InteractionScope, { dispatcher: dispatcher, context: context, attachments: [{
+                    level: 'module',
+                    behaviors: [{
+                            name: 'ModuleWide',
+                            bindings: [{
+                                    trigger: { kind: InteractionTriggerKind.Click },
+                                    actions: [{ kind: InteractionActionKind.Notify, level: NotificationLevel.Info, message: { text: 'from the module' } }],
+                                }],
+                        }],
+                }], children: _jsx(Button, { behaviors: [cancelOnClick] }) }));
+        await userEvent.click(screen.getByRole('button'));
+        calls.should.eql([
+            'notify:Info:from the module',
+            'executeCommand:CancelInvoice:{"invoiceId":"<item.invoiceId>"}',
+            'refreshQuery:Invoices',
+        ]);
+    });
+    it('should not run a binding whose guard is false', async () => {
+        render(_jsx(InteractionScope, { dispatcher: dispatcher, context: { resolve: () => false }, attachments: [], children: _jsx(Button, { behaviors: [{
+                        name: 'Guarded',
+                        bindings: [{
+                                trigger: { kind: InteractionTriggerKind.Click },
+                                condition: { path: 'item.canCancel' },
+                                actions: [{ kind: InteractionActionKind.ExecuteCommand, command: 'CancelInvoice' }],
+                            }],
+                    }] }) }));
+        await userEvent.click(screen.getByRole('button'));
+        calls.should.have.lengthOf(0);
+    });
+});
+//# sourceMappingURL=when_clicking_an_element_that_executes_a_command.js.map

package/dist/esm/for_useInteractions/when_clicking_an_element_that_executes_a_command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"when_clicking_an_element_that_executes_a_command.js","sourceRoot":"","sources":["../../../for_useInteractions/when_clicking_an_element_that_executes_a_command.tsx"],"names":[],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -4,4 +4,5 @@ export * from './core';
 export * from './NavBar';
 export * from './packages';
 export * from './theme';
+export * from './interactions';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC"}

package/dist/esm/index.js

@@ -1,6 +1,7 @@
 export { SceneElementView } from './SceneElementView.js';
 export { UnresolvedComponent } from './renderer/UnresolvedComponent.js';
 export { createReactRenderer } from './renderer/createReactRenderer.js';
+export { InteractiveComponent } from './renderer/InteractiveComponent.js';
 export { CoreText } from './core/CoreText.js';
 export { CoreButton } from './core/CoreButton.js';
 export { CoreCard } from './core/CoreCard.js';
@@ -12,4 +13,7 @@ export { extractNavigationItem } from './NavBar/extractNavigationItem.js';
 export { componentRegistryKey, mergePackageRegistries, validatePackageBundle } from './packages/ScenePackageBundle.js';
 export { applyThemeTokens, themeTokenPrefix, themeTokenProperty } from './theme/themeTokens.js';
 export { SceneThemeProvider, useSceneTheme } from './theme/SceneThemeProvider.js';
+export { InteractionScope, attachmentFor, useInteractionScope } from './interactions/InteractionScope.js';
+export { useInteractions } from './interactions/useInteractions.js';
+export { createBrowserDispatcher } from './interactions/createBrowserDispatcher.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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

package/dist/esm/interactions/InteractionScope.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { ActionDispatcher, BehaviorAttachment, InteractionContext, InteractionFinding } from '@cratis/scene.engine';
+import { Behavior } from '@cratis/scene.model';
+export interface InteractionScopeValue {
+    dispatcher: ActionDispatcher;
+    context: InteractionContext;
+    attachments: BehaviorAttachment[];
+    onFindings?: (findings: InteractionFinding[]) => void;
+}
+export interface InteractionScopeProps extends InteractionScopeValue {
+    children: ReactNode;
+}
+export declare function InteractionScope({ children, dispatcher, context, attachments, onFindings }: InteractionScopeProps): import("react").JSX.Element;
+export declare function useInteractionScope(): InteractionScopeValue | undefined;
+export declare function attachmentFor(level: string, behaviors?: Behavior[]): BehaviorAttachment[];
+//# sourceMappingURL=InteractionScope.d.ts.map

package/dist/esm/interactions/InteractionScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionScope.d.ts","sourceRoot":"","sources":["../../../interactions/InteractionScope.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAsC,MAAM,OAAO,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACpH,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAK/C,MAAM,WAAW,qBAAqB;IAElC,UAAU,EAAE,gBAAgB,CAAC;IAG7B,OAAO,EAAE,kBAAkB,CAAC;IAG5B,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAGlC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,kBAAkB,EAAE,KAAK,IAAI,CAAC;CACzD;AAID,MAAM,WAAW,qBAAsB,SAAQ,qBAAqB;IAChE,QAAQ,EAAE,SAAS,CAAC;CACvB;AAUD,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,qBAAqB,+BAWjH;AAWD,wBAAgB,mBAAmB,IAAI,qBAAqB,GAAG,SAAS,CAEvE;AASD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,QAAQ,EAAE,GAAG,kBAAkB,EAAE,CAEzF"}

package/dist/esm/interactions/InteractionScope.js

@@ -0,0 +1,61 @@
+import { jsx } from 'react/jsx-runtime';
+import { useContext, useMemo, createContext } from 'react';
+
+const Scope = /*#__PURE__*/ createContext(undefined);
+/**
+ * Provides the dispatcher, the resolution context and the enclosing attachments to everything beneath it.
+ *
+ * Attachments nest: a scope inside another scope appends to it rather than replacing it, so an element's
+ * enclosing chain is assembled by the tree rather than reconstructed at each leaf. That is what keeps the
+ * additive rule true in a renderer - a module's behavior is still in scope at a button six levels down,
+ * without the button knowing the module exists.
+ */ function InteractionScope({ children, dispatcher, context, attachments, onFindings }) {
+    const enclosing = useContext(Scope);
+    const value = useMemo(()=>({
+            dispatcher,
+            context,
+            attachments: [
+                ...enclosing?.attachments ?? [],
+                ...attachments
+            ],
+            onFindings: onFindings ?? enclosing?.onFindings
+        }), [
+        dispatcher,
+        context,
+        attachments,
+        onFindings,
+        enclosing
+    ]);
+    return /*#__PURE__*/ jsx(Scope.Provider, {
+        value: value,
+        children: children
+    });
+}
+/**
+ * Reads the enclosing interaction scope.
+ *
+ * @returns The scope, or `undefined` when the tree is rendered without one.
+ * @remarks
+ * Rendering without a scope is legitimate - a preview surface showing what a screen looks like has nothing to
+ * dispatch to - so this answers `undefined` rather than throwing. What must not happen is an element silently
+ * appearing interactive when nothing can run; {@link useInteractions} is where that is decided.
+ */ function useInteractionScope() {
+    return useContext(Scope);
+}
+/**
+ * Builds the attachment list for one element, so a caller does not have to know the shape.
+ *
+ * @param level What is being attached to, used when reporting.
+ * @param behaviors The behaviors attached there.
+ * @returns The attachment, or an empty list when there are none.
+ */ function attachmentFor(level, behaviors) {
+    return behaviors && behaviors.length > 0 ? [
+        {
+            level,
+            behaviors
+        }
+    ] : [];
+}
+
+export { InteractionScope, attachmentFor, useInteractionScope };
+//# sourceMappingURL=InteractionScope.js.map

package/dist/esm/interactions/InteractionScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionScope.js","sources":["../../../interactions/InteractionScope.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, createContext, useContext, useMemo } from 'react';\nimport { ActionDispatcher, BehaviorAttachment, InteractionContext, InteractionFinding } from '@cratis/scene.engine';\nimport { Behavior } from '@cratis/scene.model';\n\n/**\n * What the elements beneath a scope need in order to run an interaction.\n */\nexport interface InteractionScopeValue {\n    /** The seam that performs the effects. */\n    dispatcher: ActionDispatcher;\n\n    /** How bindings and localization resolve. */\n    context: InteractionContext;\n\n    /** The attachments enclosing this point, outermost first. */\n    attachments: BehaviorAttachment[];\n\n    /** Where a finding goes. Absent means nothing is listening, which is itself worth knowing. */\n    onFindings?: (findings: InteractionFinding[]) => void;\n}\n\nconst Scope = createContext<InteractionScopeValue | undefined>(undefined);\n\nexport interface InteractionScopeProps extends InteractionScopeValue {\n    children: ReactNode;\n}\n\n/**\n * Provides the dispatcher, the resolution context and the enclosing attachments to everything beneath it.\n *\n * Attachments nest: a scope inside another scope appends to it rather than replacing it, so an element's\n * enclosing chain is assembled by the tree rather than reconstructed at each leaf. That is what keeps the\n * additive rule true in a renderer - a module's behavior is still in scope at a button six levels down,\n * without the button knowing the module exists.\n */\nexport function InteractionScope({ children, dispatcher, context, attachments, onFindings }: InteractionScopeProps) {\n    const enclosing = useContext(Scope);\n\n    const value = useMemo<InteractionScopeValue>(() => ({\n        dispatcher,\n        context,\n        attachments: [...(enclosing?.attachments ?? []), ...attachments],\n        onFindings: onFindings ?? enclosing?.onFindings,\n    }), [dispatcher, context, attachments, onFindings, enclosing]);\n\n    return <Scope.Provider value={value}>{children}</Scope.Provider>;\n}\n\n/**\n * Reads the enclosing interaction scope.\n *\n * @returns The scope, or `undefined` when the tree is rendered without one.\n * @remarks\n * Rendering without a scope is legitimate - a preview surface showing what a screen looks like has nothing to\n * dispatch to - so this answers `undefined` rather than throwing. What must not happen is an element silently\n * appearing interactive when nothing can run; {@link useInteractions} is where that is decided.\n */\nexport function useInteractionScope(): InteractionScopeValue | undefined {\n    return useContext(Scope);\n}\n\n/**\n * Builds the attachment list for one element, so a caller does not have to know the shape.\n *\n * @param level What is being attached to, used when reporting.\n * @param behaviors The behaviors attached there.\n * @returns The attachment, or an empty list when there are none.\n */\nexport function attachmentFor(level: string, behaviors?: Behavior[]): BehaviorAttachment[] {\n    return behaviors && behaviors.length > 0 ? [{ level, behaviors }] : [];\n}\n"],"names":["Scope","createContext","undefined","InteractionScope","children","dispatcher","context","attachments","onFindings","enclosing","useContext","value","useMemo","_jsx","Provider","useInteractionScope","attachmentFor","level","behaviors","length"],"mappings":";;;AAwBA,MAAMA,sBAAQC,aAAAA,CAAiDC,SAAAA,CAAAA;AAM/D;;;;;;;AAOC,IACM,SAASC,gBAAAA,CAAiB,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,OAAO,EAAEC,WAAW,EAAEC,UAAU,EAAyB,EAAA;AAC9G,IAAA,MAAMC,YAAYC,UAAAA,CAAWV,KAAAA,CAAAA;IAE7B,MAAMW,KAAAA,GAAQC,OAAAA,CAA+B,KAAO;AAChDP,YAAAA,UAAAA;AACAC,YAAAA,OAAAA;YACAC,WAAAA,EAAa;AAAKE,gBAAAA,GAAAA,SAAAA,EAAWF,eAAe,EAAE;AAAMA,gBAAAA,GAAAA;AAAY,aAAA;AAChEC,YAAAA,UAAAA,EAAYA,cAAcC,SAAAA,EAAWD;AACzC,SAAA,CAAA,EAAI;AAACH,QAAAA,UAAAA;AAAYC,QAAAA,OAAAA;AAASC,QAAAA,WAAAA;AAAaC,QAAAA,UAAAA;AAAYC,QAAAA;AAAU,KAAA,CAAA;IAE7D,qBAAOI,GAAA,CAACb,MAAMc,QAAQ,EAAA;QAACH,KAAAA,EAAOA,KAAAA;AAAQP,QAAAA,QAAAA,EAAAA;;AAC1C;AAEA;;;;;;;;AAQC,IACM,SAASW,mBAAAA,GAAAA;AACZ,IAAA,OAAOL,UAAAA,CAAWV,KAAAA,CAAAA;AACtB;AAEA;;;;;;AAMC,IACM,SAASgB,aAAAA,CAAcC,KAAa,EAAEC,SAAsB,EAAA;AAC/D,IAAA,OAAOA,SAAAA,IAAaA,SAAAA,CAAUC,MAAM,GAAG,CAAA,GAAI;AAAC,QAAA;AAAEF,YAAAA,KAAAA;AAAOC,YAAAA;AAAU;AAAE,KAAA,GAAG,EAAE;AAC1E;;"}

package/dist/esm/interactions/createBrowserDispatcher.d.ts

@@ -0,0 +1,17 @@
+import { ActionDispatcher, CommandOutcome, DialogOutcome } from '@cratis/scene.engine';
+import { NotificationLevel } from '@cratis/scene.model';
+export interface BrowserDispatcherHost {
+    executeCommand?: (command: string, args: Record<string, unknown>) => Promise<CommandOutcome>;
+    navigate?: (screen: string, args: Record<string, unknown>) => void;
+    navigateBack?: () => void;
+    openDialog?: (dialogTemplate: string, args: Record<string, unknown>) => Promise<DialogOutcome>;
+    closeDialog?: () => void;
+    refreshQuery?: (query: string) => Promise<void>;
+    setState?: (target: string, value: unknown) => void;
+    notify?: (level: NotificationLevel, message: string) => void;
+    confirm?: (message: string) => Promise<boolean>;
+    raise?: (trigger: string, args: Record<string, unknown>) => Promise<void>;
+    onUnsupported?: (action: string) => void;
+}
+export declare function createBrowserDispatcher(host?: BrowserDispatcherHost): ActionDispatcher;
+//# sourceMappingURL=createBrowserDispatcher.d.ts.map

package/dist/esm/interactions/createBrowserDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBrowserDispatcher.d.ts","sourceRoot":"","sources":["../../../interactions/createBrowserDispatcher.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AASxD,MAAM,WAAW,qBAAqB;IAElC,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAG7F,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAGnE,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAG1B,UAAU,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IAG/F,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IAGzB,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAGhD,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAGpD,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAG7D,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAGhD,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAG1E,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAYD,wBAAgB,uBAAuB,CAAC,IAAI,GAAE,qBAA0B,GAAG,gBAAgB,CAqG1F"}

package/dist/esm/interactions/createBrowserDispatcher.js

@@ -0,0 +1,100 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Creates the dispatcher a browser host uses.
+ *
+ * This is the only place in Scene.React that knows an action has to *happen*. Everything about which actions
+ * run and in what order is the engine's, which is why this file is a list of one-line delegations and holds no
+ * rules of its own.
+ *
+ * @param host What the surrounding application can actually do.
+ * @returns The {@link ActionDispatcher}.
+ */ function createBrowserDispatcher(host = {}) {
+    const unsupported = (action)=>{
+        host.onUnsupported?.(action);
+        console.warn(`[scene] The host cannot '${action}', so the interaction stopped there.`);
+    };
+    return {
+        async executeCommand (command, args) {
+            if (!host.executeCommand) {
+                unsupported(`execute ${command}`);
+                // Reported as a failure, so the document's own `on failure` runs. Answering success would
+                // make a command that never reached a backend look like one that worked.
+                return {
+                    isSuccess: false,
+                    validationErrors: []
+                };
+            }
+            return host.executeCommand(command, args);
+        },
+        navigate (screen, args) {
+            if (host.navigate) {
+                host.navigate(screen, args);
+                return;
+            }
+            unsupported(`navigate to ${screen}`);
+        },
+        navigateBack () {
+            if (host.navigateBack) {
+                host.navigateBack();
+                return;
+            }
+            unsupported('navigate back');
+        },
+        async openDialog (dialogTemplate, args) {
+            if (!host.openDialog) {
+                unsupported(`open dialog ${dialogTemplate}`);
+                return {
+                    isConfirmed: false
+                };
+            }
+            return host.openDialog(dialogTemplate, args);
+        },
+        closeDialog () {
+            if (host.closeDialog) {
+                host.closeDialog();
+                return;
+            }
+            unsupported('close dialog');
+        },
+        async refreshQuery (query) {
+            if (host.refreshQuery) {
+                await host.refreshQuery(query);
+                return;
+            }
+            unsupported(`refresh ${query}`);
+        },
+        setState (target, value) {
+            if (host.setState) {
+                host.setState(target, value);
+                return;
+            }
+            unsupported(`set ${target}`);
+        },
+        notify (level, message) {
+            if (host.notify) {
+                host.notify(level, message);
+                return;
+            }
+            // The console is a poor notification, but it is a real one - and a host that has not wired
+            // notifications yet should still see what the document wanted to say.
+            console.log(`[scene:${level}] ${message}`);
+        },
+        async confirm (message) {
+            if (host.confirm) return host.confirm(message);
+            // The browser's own prompt is the honest default: a confirm exists to gate what follows, so
+            // answering `true` without asking anyone would remove the gate rather than approximate it.
+            return typeof globalThis.confirm === 'function' ? globalThis.confirm(message) : false;
+        },
+        async raise (trigger, args) {
+            if (host.raise) {
+                await host.raise(trigger, args);
+                return;
+            }
+            unsupported(`raise ${trigger}`);
+        }
+    };
+}
+
+export { createBrowserDispatcher };
+//# sourceMappingURL=createBrowserDispatcher.js.map

package/dist/esm/interactions/createBrowserDispatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBrowserDispatcher.js","sources":["../../../interactions/createBrowserDispatcher.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ActionDispatcher, CommandOutcome, DialogOutcome } from '@cratis/scene.engine';\nimport { NotificationLevel } from '@cratis/scene.model';\n\n/**\n * What a host has to supply for an interaction to reach anything real.\n *\n * Every member is optional and every one that is missing is *reported* rather than quietly ignored. A host\n * that cannot execute commands is a legitimate state - a preview surface, a design tool - but a button that\n * appears to work and does nothing is not.\n */\nexport interface BrowserDispatcherHost {\n    /** Submits a command. The transport belongs to the host: Scene does not know what a backend is. */\n    executeCommand?: (command: string, args: Record<string, unknown>) => Promise<CommandOutcome>;\n\n    /** Navigates to a screen. The URL belongs to the host, which is why no route is constructed here. */\n    navigate?: (screen: string, args: Record<string, unknown>) => void;\n\n    /** Goes back. */\n    navigateBack?: () => void;\n\n    /** Opens a dialog and answers with what the user did. */\n    openDialog?: (dialogTemplate: string, args: Record<string, unknown>) => Promise<DialogOutcome>;\n\n    /** Closes the open dialog. */\n    closeDialog?: () => void;\n\n    /** Re-runs a query. */\n    refreshQuery?: (query: string) => Promise<void>;\n\n    /** Writes screen state. */\n    setState?: (target: string, value: unknown) => void;\n\n    /** Surfaces a message. Falls back to the console rather than to nothing. */\n    notify?: (level: NotificationLevel, message: string) => void;\n\n    /** Asks the user to confirm. Falls back to the browser's own prompt. */\n    confirm?: (message: string) => Promise<boolean>;\n\n    /** Raises an application trigger. */\n    raise?: (trigger: string, args: Record<string, unknown>) => Promise<void>;\n\n    /** Where an unsupported action is reported. */\n    onUnsupported?: (action: string) => void;\n}\n\n/**\n * Creates the dispatcher a browser host uses.\n *\n * This is the only place in Scene.React that knows an action has to *happen*. Everything about which actions\n * run and in what order is the engine's, which is why this file is a list of one-line delegations and holds no\n * rules of its own.\n *\n * @param host What the surrounding application can actually do.\n * @returns The {@link ActionDispatcher}.\n */\nexport function createBrowserDispatcher(host: BrowserDispatcherHost = {}): ActionDispatcher {\n    const unsupported = (action: string) => {\n        host.onUnsupported?.(action);\n        console.warn(`[scene] The host cannot '${action}', so the interaction stopped there.`);\n    };\n\n    return {\n        async executeCommand(command, args) {\n            if (!host.executeCommand) {\n                unsupported(`execute ${command}`);\n\n                // Reported as a failure, so the document's own `on failure` runs. Answering success would\n                // make a command that never reached a backend look like one that worked.\n                return { isSuccess: false, validationErrors: [] };\n            }\n\n            return host.executeCommand(command, args);\n        },\n\n        navigate(screen, args) {\n            if (host.navigate) {\n                host.navigate(screen, args);\n                return;\n            }\n\n            unsupported(`navigate to ${screen}`);\n        },\n\n        navigateBack() {\n            if (host.navigateBack) {\n                host.navigateBack();\n                return;\n            }\n\n            unsupported('navigate back');\n        },\n\n        async openDialog(dialogTemplate, args) {\n            if (!host.openDialog) {\n                unsupported(`open dialog ${dialogTemplate}`);\n                return { isConfirmed: false };\n            }\n\n            return host.openDialog(dialogTemplate, args);\n        },\n\n        closeDialog() {\n            if (host.closeDialog) {\n                host.closeDialog();\n                return;\n            }\n\n            unsupported('close dialog');\n        },\n\n        async refreshQuery(query) {\n            if (host.refreshQuery) {\n                await host.refreshQuery(query);\n                return;\n            }\n\n            unsupported(`refresh ${query}`);\n        },\n\n        setState(target, value) {\n            if (host.setState) {\n                host.setState(target, value);\n                return;\n            }\n\n            unsupported(`set ${target}`);\n        },\n\n        notify(level, message) {\n            if (host.notify) {\n                host.notify(level, message);\n                return;\n            }\n\n            // The console is a poor notification, but it is a real one - and a host that has not wired\n            // notifications yet should still see what the document wanted to say.\n            console.log(`[scene:${level}] ${message}`);\n        },\n\n        async confirm(message) {\n            if (host.confirm) return host.confirm(message);\n\n            // The browser's own prompt is the honest default: a confirm exists to gate what follows, so\n            // answering `true` without asking anyone would remove the gate rather than approximate it.\n            return typeof globalThis.confirm === 'function' ? globalThis.confirm(message) : false;\n        },\n\n        async raise(trigger, args) {\n            if (host.raise) {\n                await host.raise(trigger, args);\n                return;\n            }\n\n            unsupported(`raise ${trigger}`);\n        },\n    };\n}\n"],"names":["createBrowserDispatcher","host","unsupported","action","onUnsupported","console","warn","executeCommand","command","args","isSuccess","validationErrors","navigate","screen","navigateBack","openDialog","dialogTemplate","isConfirmed","closeDialog","refreshQuery","query","setState","target","value","notify","level","message","log","confirm","globalThis","raise","trigger"],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+export * from './InteractionScope';
+export * from './useInteractions';
+export * from './createBrowserDispatcher';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../interactions/index.ts"],"names":[],"mappings":"AAGA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC"}

package/dist/esm/interactions/index.js

@@ -0,0 +1,4 @@
+export * from './InteractionScope';
+export * from './useInteractions';
+export * from './createBrowserDispatcher';
+//# sourceMappingURL=index.js.map

package/dist/esm/interactions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../interactions/index.ts"],"names":[],"mappings":"AAGA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC"}

package/dist/esm/interactions/useInteractions.d.ts

@@ -0,0 +1,16 @@
+import { Behavior } from '@cratis/scene.model';
+export interface InteractionHandlers {
+    onClick?: (event: {
+        stopPropagation(): void;
+    }) => void;
+    onDoubleClick?: (event: {
+        stopPropagation(): void;
+    }) => void;
+    onChange?: () => void;
+    onSubmit?: (event: {
+        preventDefault(): void;
+    }) => void;
+    onSelect?: () => void;
+}
+export declare function useInteractions(level: string, behaviors?: Behavior[]): InteractionHandlers;
+//# sourceMappingURL=useInteractions.d.ts.map

package/dist/esm/interactions/useInteractions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractions.d.ts","sourceRoot":"","sources":["../../../interactions/useInteractions.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAA0B,MAAM,qBAAqB,CAAC;AAUvE,MAAM,WAAW,mBAAmB;IAChC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,eAAe,IAAI,IAAI,CAAA;KAAE,KAAK,IAAI,CAAC;IACvD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,eAAe,IAAI,IAAI,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7D,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,cAAc,IAAI,IAAI,CAAA;KAAE,KAAK,IAAI,CAAC;IACvD,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AA0BD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,QAAQ,EAAE,GAAG,mBAAmB,CAoE1F"}

package/dist/esm/interactions/useInteractions.js

@@ -0,0 +1,120 @@
+import { useMemo, useCallback, useEffect } from 'react';
+import { runBindings, resolveBehaviors, resolveIntervalBehaviors } from '@cratis/scene.engine';
+import { InteractionTriggerKind } from '@cratis/scene.model';
+import { useInteractionScope, attachmentFor } from './InteractionScope.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+const domTriggers = [
+    [
+        'onClick',
+        InteractionTriggerKind.Click
+    ],
+    [
+        'onDoubleClick',
+        InteractionTriggerKind.DoubleClick
+    ],
+    [
+        'onChange',
+        InteractionTriggerKind.Change
+    ],
+    [
+        'onSubmit',
+        InteractionTriggerKind.Submit
+    ],
+    [
+        'onSelect',
+        InteractionTriggerKind.Select
+    ]
+];
+/**
+ * Wires the behaviors attached to an element to the events that start them.
+ *
+ * The hook resolves and runs; it decides nothing. Which bindings a trigger runs, in what order, and where a
+ * sequence stops are all the engine's, so a different renderer inherits the same semantics instead of
+ * reimplementing them - and so all of it stays testable without a DOM.
+ *
+ * Lifecycle triggers are handled here rather than by the caller because React is what knows when an element
+ * mounts: `load` and `unload` follow the element, and `enter` and `leave` follow the screen. An `interval`
+ * becomes a timer that is cleared on unmount, because a document declaring one is asking for it to run while
+ * the thing it is attached to is on screen and not afterwards.
+ *
+ * @param level What is being attached to, used when reporting a finding.
+ * @param behaviors The behaviors attached to this element.
+ * @returns The handlers to spread onto the rendered element.
+ */ function useInteractions(level, behaviors) {
+    const scope = useInteractionScope();
+    const attachments = useMemo(()=>[
+            ...scope?.attachments ?? [],
+            ...attachmentFor(level, behaviors)
+        ], [
+        scope,
+        level,
+        behaviors
+    ]);
+    const run = useCallback(async (kind)=>{
+        if (!scope) return;
+        const result = await runBindings(resolveBehaviors(attachments, kind), scope.dispatcher, scope.context);
+        if (result.findings.length > 0) scope.onFindings?.(result.findings);
+    }, [
+        scope,
+        attachments
+    ]);
+    // Mount and unmount, for the element and for the screen it is on. Running the unload and leave bindings
+    // from the cleanup is what makes them reliable: React guarantees it, a component remembering to call
+    // something on the way out does not.
+    useEffect(()=>{
+        void run(InteractionTriggerKind.Load);
+        void run(InteractionTriggerKind.Enter);
+        return ()=>{
+            void run(InteractionTriggerKind.Unload);
+            void run(InteractionTriggerKind.Leave);
+        };
+    }, [
+        run
+    ]);
+    useEffect(()=>{
+        const intervals = resolveIntervalBehaviors(attachments);
+        if (intervals.length === 0 || !scope) return;
+        const timers = intervals.map((candidate)=>{
+            const seconds = candidate.binding.trigger.seconds ?? 0;
+            return setInterval(()=>void runBindings([
+                    candidate
+                ], scope.dispatcher, scope.context), Math.max(seconds, 1) * 1000);
+        });
+        return ()=>timers.forEach(clearInterval);
+    }, [
+        attachments,
+        scope
+    ]);
+    return useMemo(()=>{
+        const handlers = {};
+        if (!scope) return handlers;
+        for (const [handler, kind] of domTriggers){
+            // Nothing attached for this trigger means no handler at all. Attaching an empty one would make
+            // every element look interactive and would stop clicks reaching whatever encloses it.
+            if (resolveBehaviors(attachments, kind).length === 0) continue;
+            if (handler === 'onSubmit') {
+                handlers.onSubmit = (event)=>{
+                    event.preventDefault();
+                    void run(kind);
+                };
+                continue;
+            }
+            handlers[handler] = (event)=>{
+                // An interaction that ran here is handled here. Without this, a click on a row inside a table
+                // that both declare `on click` would run the table's twice: once for the row, once on the way up.
+                event?.stopPropagation();
+                void run(kind);
+            };
+        }
+        return handlers;
+    }, [
+        scope,
+        attachments,
+        run
+    ]);
+}
+
+export { useInteractions };
+//# sourceMappingURL=useInteractions.js.map

package/dist/esm/interactions/useInteractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractions.js","sources":["../../../interactions/useInteractions.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { useCallback, useEffect, useMemo } from 'react';\nimport { BehaviorAttachment, resolveBehaviors, resolveIntervalBehaviors, runBindings } from '@cratis/scene.engine';\nimport { Behavior, InteractionTriggerKind } from '@cratis/scene.model';\nimport { attachmentFor, useInteractionScope } from './InteractionScope';\n\n/**\n * The DOM handlers an element should spread onto whatever it renders.\n *\n * Only the handlers a document actually asks for are present. An element with no `on click` gets no `onClick`,\n * so it does not become clickable - and, just as importantly, does not swallow the click from something\n * enclosing it that does.\n */\nexport interface InteractionHandlers {\n    onClick?: (event: { stopPropagation(): void }) => void;\n    onDoubleClick?: (event: { stopPropagation(): void }) => void;\n    onChange?: () => void;\n    onSubmit?: (event: { preventDefault(): void }) => void;\n    onSelect?: () => void;\n}\n\nconst domTriggers: [keyof InteractionHandlers, InteractionTriggerKind][] = [\n    ['onClick', InteractionTriggerKind.Click],\n    ['onDoubleClick', InteractionTriggerKind.DoubleClick],\n    ['onChange', InteractionTriggerKind.Change],\n    ['onSubmit', InteractionTriggerKind.Submit],\n    ['onSelect', InteractionTriggerKind.Select],\n];\n\n/**\n * Wires the behaviors attached to an element to the events that start them.\n *\n * The hook resolves and runs; it decides nothing. Which bindings a trigger runs, in what order, and where a\n * sequence stops are all the engine's, so a different renderer inherits the same semantics instead of\n * reimplementing them - and so all of it stays testable without a DOM.\n *\n * Lifecycle triggers are handled here rather than by the caller because React is what knows when an element\n * mounts: `load` and `unload` follow the element, and `enter` and `leave` follow the screen. An `interval`\n * becomes a timer that is cleared on unmount, because a document declaring one is asking for it to run while\n * the thing it is attached to is on screen and not afterwards.\n *\n * @param level What is being attached to, used when reporting a finding.\n * @param behaviors The behaviors attached to this element.\n * @returns The handlers to spread onto the rendered element.\n */\nexport function useInteractions(level: string, behaviors?: Behavior[]): InteractionHandlers {\n    const scope = useInteractionScope();\n\n    const attachments = useMemo<BehaviorAttachment[]>(\n        () => [...(scope?.attachments ?? []), ...attachmentFor(level, behaviors)],\n        [scope, level, behaviors]);\n\n    const run = useCallback(async (kind: InteractionTriggerKind) => {\n        if (!scope) return;\n\n        const result = await runBindings(resolveBehaviors(attachments, kind), scope.dispatcher, scope.context);\n        if (result.findings.length > 0) scope.onFindings?.(result.findings);\n    }, [scope, attachments]);\n\n    // Mount and unmount, for the element and for the screen it is on. Running the unload and leave bindings\n    // from the cleanup is what makes them reliable: React guarantees it, a component remembering to call\n    // something on the way out does not.\n    useEffect(() => {\n        void run(InteractionTriggerKind.Load);\n        void run(InteractionTriggerKind.Enter);\n\n        return () => {\n            void run(InteractionTriggerKind.Unload);\n            void run(InteractionTriggerKind.Leave);\n        };\n    }, [run]);\n\n    useEffect(() => {\n        const intervals = resolveIntervalBehaviors(attachments);\n        if (intervals.length === 0 || !scope) return;\n\n        const timers = intervals.map(candidate => {\n            const seconds = (candidate.binding.trigger as { seconds?: number }).seconds ?? 0;\n            return setInterval(\n                () => void runBindings([candidate], scope.dispatcher, scope.context),\n                Math.max(seconds, 1) * 1000);\n        });\n\n        return () => timers.forEach(clearInterval);\n    }, [attachments, scope]);\n\n    return useMemo(() => {\n        const handlers: InteractionHandlers = {};\n        if (!scope) return handlers;\n\n        for (const [handler, kind] of domTriggers) {\n            // Nothing attached for this trigger means no handler at all. Attaching an empty one would make\n            // every element look interactive and would stop clicks reaching whatever encloses it.\n            if (resolveBehaviors(attachments, kind).length === 0) continue;\n\n            if (handler === 'onSubmit') {\n                handlers.onSubmit = event => {\n                    event.preventDefault();\n                    void run(kind);\n                };\n                continue;\n            }\n\n            handlers[handler] = ((event?: { stopPropagation(): void }) => {\n                // An interaction that ran here is handled here. Without this, a click on a row inside a table\n                // that both declare `on click` would run the table's twice: once for the row, once on the way up.\n                event?.stopPropagation();\n                void run(kind);\n            }) as never;\n        }\n\n        return handlers;\n    }, [scope, attachments, run]);\n}\n"],"names":["domTriggers","InteractionTriggerKind","Click","DoubleClick","Change","Submit","Select","useInteractions","level","behaviors","scope","useInteractionScope","attachments","useMemo","attachmentFor","run","useCallback","kind","result","runBindings","resolveBehaviors","dispatcher","context","findings","length","onFindings","useEffect","Load","Enter","Unload","Leave","intervals","resolveIntervalBehaviors","timers","map","candidate","seconds","binding","trigger","setInterval","Math","max","forEach","clearInterval","handlers","handler","onSubmit","event","preventDefault","stopPropagation"],"mappings":"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"}

package/dist/esm/renderer/ComponentRegistry.d.ts

@@ -1,8 +1,10 @@
 import { ComponentType, ReactNode } from 'react';
 import { ExternalComponent } from '@cratis/scene.model';
+import { InteractionHandlers } from '../interactions';
 export interface RegisteredComponentProps {
     element: ExternalComponent;
     slots: Record<string, ReactNode[]>;
+    interactions?: InteractionHandlers;
 }
 export type ComponentRegistry = Record<string, ComponentType<RegisteredComponentProps>>;
 //# sourceMappingURL=ComponentRegistry.d.ts.map

package/dist/esm/renderer/ComponentRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComponentRegistry.d.ts","sourceRoot":"","sources":["../../../renderer/ComponentRegistry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAKxD,MAAM,WAAW,wBAAwB;IACrC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;CACtC;AAUD,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"ComponentRegistry.d.ts","sourceRoot":"","sources":["../../../renderer/ComponentRegistry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAKtD,MAAM,WAAW,wBAAwB;IACrC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAUnC,YAAY,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAUD,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAC,CAAC"}

package/dist/esm/renderer/InteractiveComponent.d.ts

@@ -0,0 +1,10 @@
+import { ComponentType, ReactNode } from 'react';
+import { ExternalComponent } from '@cratis/scene.model';
+import { RegisteredComponentProps } from './ComponentRegistry';
+export interface InteractiveComponentProps {
+    component: ComponentType<RegisteredComponentProps>;
+    element: ExternalComponent;
+    slots: Record<string, ReactNode[]>;
+}
+export declare function InteractiveComponent({ component, element, slots }: InteractiveComponentProps): import("react").ReactElement<RegisteredComponentProps, string | import("react").JSXElementConstructor<any>>;
+//# sourceMappingURL=InteractiveComponent.d.ts.map

package/dist/esm/renderer/InteractiveComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractiveComponent.d.ts","sourceRoot":"","sources":["../../../renderer/InteractiveComponent.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAiB,MAAM,OAAO,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,MAAM,WAAW,yBAAyB;IACtC,SAAS,EAAE,aAAa,CAAC,wBAAwB,CAAC,CAAC;IACnD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;CACtC;AASD,wBAAgB,oBAAoB,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,yBAAyB,+GAG5F"}

package/dist/esm/renderer/InteractiveComponent.js

@@ -0,0 +1,23 @@
+import { createElement } from 'react';
+import 'react/jsx-runtime';
+import { useInteractions } from '../interactions/useInteractions.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Resolves an element's interactions and hands them to the component that renders it.
+ *
+ * This exists as a component rather than as a call inside the renderer because resolving them is a hook, and a
+ * hook cannot run inside the plain function a {@link Renderer} is. Keeping the renderer plain is what lets the
+ * same element tree be rendered by something that is not React at all.
+ */ function InteractiveComponent({ component, element, slots }) {
+    const interactions = useInteractions(element.id, element.behaviors);
+    return /*#__PURE__*/ createElement(component, {
+        element,
+        slots,
+        interactions
+    });
+}
+
+export { InteractiveComponent };
+//# sourceMappingURL=InteractiveComponent.js.map

package/dist/esm/renderer/InteractiveComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractiveComponent.js","sources":["../../../renderer/InteractiveComponent.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 { ComponentType, ReactNode, createElement } from 'react';\nimport { ExternalComponent } from '@cratis/scene.model';\nimport { useInteractions } from '../interactions';\nimport { RegisteredComponentProps } from './ComponentRegistry';\n\nexport interface InteractiveComponentProps {\n    component: ComponentType<RegisteredComponentProps>;\n    element: ExternalComponent;\n    slots: Record<string, ReactNode[]>;\n}\n\n/**\n * Resolves an element's interactions and hands them to the component that renders it.\n *\n * This exists as a component rather than as a call inside the renderer because resolving them is a hook, and a\n * hook cannot run inside the plain function a {@link Renderer} is. Keeping the renderer plain is what lets the\n * same element tree be rendered by something that is not React at all.\n */\nexport function InteractiveComponent({ component, element, slots }: InteractiveComponentProps) {\n    const interactions = useInteractions(element.id, element.behaviors);\n    return createElement(component, { element, slots, interactions });\n}\n"],"names":["InteractiveComponent","component","element","slots","interactions","useInteractions","id","behaviors","createElement"],"mappings":";;;;AAAA;AACA;AAaA;;;;;;IAOO,SAASA,oBAAAA,CAAqB,EAAEC,SAAS,EAAEC,OAAO,EAAEC,KAAK,EAA6B,EAAA;AACzF,IAAA,MAAMC,eAAeC,eAAAA,CAAgBH,OAAAA,CAAQI,EAAE,EAAEJ,QAAQK,SAAS,CAAA;AAClE,IAAA,qBAAOC,cAAcP,SAAAA,EAAW;AAAEC,QAAAA,OAAAA;AAASC,QAAAA,KAAAA;AAAOC,QAAAA;AAAa,KAAA,CAAA;AACnE;;"}