@cratis/scene.react 3.7.0 → 4.1.0

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":"AAAA;AACA;AA+CA;;;;;;;;;AASC,IACM,SAASA,uBAAAA,CAAwBC,IAAAA,GAA8B,EAAE,EAAA;AACpE,IAAA,MAAMC,cAAc,CAACC,MAAAA,GAAAA;AACjBF,QAAAA,IAAAA,CAAKG,aAAa,GAAGD,MAAAA,CAAAA;AACrBE,QAAAA,OAAAA,CAAQC,IAAI,CAAC,CAAC,yBAAyB,EAAEH,MAAAA,CAAO,oCAAoC,CAAC,CAAA;AACzF,IAAA,CAAA;IAEA,OAAO;QACH,MAAMI,cAAAA,CAAAA,CAAeC,OAAO,EAAEC,IAAI,EAAA;YAC9B,IAAI,CAACR,IAAAA,CAAKM,cAAc,EAAE;gBACtBL,WAAAA,CAAY,CAAC,QAAQ,EAAEM,OAAAA,CAAAA,CAAS,CAAA;;;gBAIhC,OAAO;oBAAEE,SAAAA,EAAW,KAAA;AAAOC,oBAAAA,gBAAAA,EAAkB;AAAG,iBAAA;AACpD,YAAA;YAEA,OAAOV,IAAAA,CAAKM,cAAc,CAACC,OAAAA,EAASC,IAAAA,CAAAA;AACxC,QAAA,CAAA;QAEAG,QAAAA,CAAAA,CAASC,MAAM,EAAEJ,IAAI,EAAA;YACjB,IAAIR,IAAAA,CAAKW,QAAQ,EAAE;gBACfX,IAAAA,CAAKW,QAAQ,CAACC,MAAAA,EAAQJ,IAAAA,CAAAA;AACtB,gBAAA;AACJ,YAAA;YAEAP,WAAAA,CAAY,CAAC,YAAY,EAAEW,MAAAA,CAAAA,CAAQ,CAAA;AACvC,QAAA,CAAA;AAEAC,QAAAA,YAAAA,CAAAA,GAAAA;YACI,IAAIb,IAAAA,CAAKa,YAAY,EAAE;AACnBb,gBAAAA,IAAAA,CAAKa,YAAY,EAAA;AACjB,gBAAA;AACJ,YAAA;YAEAZ,WAAAA,CAAY,eAAA,CAAA;AAChB,QAAA,CAAA;QAEA,MAAMa,UAAAA,CAAAA,CAAWC,cAAc,EAAEP,IAAI,EAAA;YACjC,IAAI,CAACR,IAAAA,CAAKc,UAAU,EAAE;gBAClBb,WAAAA,CAAY,CAAC,YAAY,EAAEc,cAAAA,CAAAA,CAAgB,CAAA;gBAC3C,OAAO;oBAAEC,WAAAA,EAAa;AAAM,iBAAA;AAChC,YAAA;YAEA,OAAOhB,IAAAA,CAAKc,UAAU,CAACC,cAAAA,EAAgBP,IAAAA,CAAAA;AAC3C,QAAA,CAAA;AAEAS,QAAAA,WAAAA,CAAAA,GAAAA;YACI,IAAIjB,IAAAA,CAAKiB,WAAW,EAAE;AAClBjB,gBAAAA,IAAAA,CAAKiB,WAAW,EAAA;AAChB,gBAAA;AACJ,YAAA;YAEAhB,WAAAA,CAAY,cAAA,CAAA;AAChB,QAAA,CAAA;AAEA,QAAA,MAAMiB,cAAaC,KAAK,EAAA;YACpB,IAAInB,IAAAA,CAAKkB,YAAY,EAAE;gBACnB,MAAMlB,IAAAA,CAAKkB,YAAY,CAACC,KAAAA,CAAAA;AACxB,gBAAA;AACJ,YAAA;YAEAlB,WAAAA,CAAY,CAAC,QAAQ,EAAEkB,KAAAA,CAAAA,CAAO,CAAA;AAClC,QAAA,CAAA;QAEAC,QAAAA,CAAAA,CAASC,MAAM,EAAEC,KAAK,EAAA;YAClB,IAAItB,IAAAA,CAAKoB,QAAQ,EAAE;gBACfpB,IAAAA,CAAKoB,QAAQ,CAACC,MAAAA,EAAQC,KAAAA,CAAAA;AACtB,gBAAA;AACJ,YAAA;YAEArB,WAAAA,CAAY,CAAC,IAAI,EAAEoB,MAAAA,CAAAA,CAAQ,CAAA;AAC/B,QAAA,CAAA;QAEAE,MAAAA,CAAAA,CAAOC,KAAK,EAAEC,OAAO,EAAA;YACjB,IAAIzB,IAAAA,CAAKuB,MAAM,EAAE;gBACbvB,IAAAA,CAAKuB,MAAM,CAACC,KAAAA,EAAOC,OAAAA,CAAAA;AACnB,gBAAA;AACJ,YAAA;;;YAIArB,OAAAA,CAAQsB,GAAG,CAAC,CAAC,OAAO,EAAEF,KAAAA,CAAM,EAAE,EAAEC,OAAAA,CAAAA,CAAS,CAAA;AAC7C,QAAA,CAAA;AAEA,QAAA,MAAME,SAAQF,OAAO,EAAA;AACjB,YAAA,IAAIzB,KAAK2B,OAAO,EAAE,OAAO3B,IAAAA,CAAK2B,OAAO,CAACF,OAAAA,CAAAA;;;YAItC,OAAO,OAAOG,WAAWD,OAAO,KAAK,aAAaC,UAAAA,CAAWD,OAAO,CAACF,OAAAA,CAAAA,GAAW,KAAA;AACpF,QAAA,CAAA;QAEA,MAAMI,KAAAA,CAAAA,CAAMC,OAAO,EAAEtB,IAAI,EAAA;YACrB,IAAIR,IAAAA,CAAK6B,KAAK,EAAE;gBACZ,MAAM7B,IAAAA,CAAK6B,KAAK,CAACC,OAAAA,EAAStB,IAAAA,CAAAA;AAC1B,gBAAA;AACJ,YAAA;YAEAP,WAAAA,CAAY,CAAC,MAAM,EAAE6B,OAAAA,CAAAA,CAAS,CAAA;AAClC,QAAA;AACJ,KAAA;AACJ;;"}

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

@@ -0,0 +1,11 @@
+export * from './InteractionScope';
+export * from './useInteractions';
+export * from './createBrowserDispatcher';
+export * from './ConfirmHost';
+export * from './ConfirmRequest';
+export * from './NotificationHost';
+export * from './SceneNotification';
+export * from './UnresolvedAction';
+export * from './UnresolvedActionHost';
+export * from './useInteractionHosts';
+//# 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;AAC1C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC"}

package/dist/esm/interactions/index.js

@@ -0,0 +1,11 @@
+export * from './InteractionScope';
+export * from './useInteractions';
+export * from './createBrowserDispatcher';
+export * from './ConfirmHost';
+export * from './ConfirmRequest';
+export * from './NotificationHost';
+export * from './SceneNotification';
+export * from './UnresolvedAction';
+export * from './UnresolvedActionHost';
+export * from './useInteractionHosts';
+//# 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;AAC1C,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC"}

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

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { BrowserDispatcherHost } from './createBrowserDispatcher';
+export interface InteractionHosts {
+    readonly host: Pick<BrowserDispatcherHost, 'notify' | 'confirm' | 'onUnsupported'>;
+    readonly surfaces: ReactNode;
+}
+export interface InteractionHostOptions {
+    readonly dismissAfter?: number;
+}
+export declare function useInteractionHosts(options?: InteractionHostOptions): InteractionHosts;
+//# sourceMappingURL=useInteractionHosts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionHosts.d.ts","sourceRoot":"","sources":["../../../interactions/useInteractionHosts.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAA0C,MAAM,OAAO,CAAC;AAE1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAWlE,MAAM,WAAW,gBAAgB;IAE7B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,EAAE,QAAQ,GAAG,SAAS,GAAG,eAAe,CAAC,CAAC;IAGnF,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAChC;AAKD,MAAM,WAAW,sBAAsB;IAEnC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAClC;AAuBD,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,sBAA2B,GAAG,gBAAgB,CA+C1F"}

package/dist/esm/interactions/useInteractionHosts.js

@@ -0,0 +1,107 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { useState, useRef, useCallback, useMemo } from 'react';
+import { ConfirmHost } from './ConfirmHost.js';
+import { NotificationHost } from './NotificationHost.js';
+import { UnresolvedActionHost } from './UnresolvedActionHost.js';
+
+/**
+ * Provides the default surfaces for the actions that need somewhere to appear.
+ *
+ * `notify` and `confirm` are the two actions a document can take that have no backend and no route: they are
+ * purely things the user sees. Without a surface, a host either invents one or the action goes to the console,
+ * which is why these ship with Scene rather than being every application's first chore.
+ *
+ * The three are returned as one unit because they are wired the same way and forgetting to render one of them
+ * is exactly the failure they exist to prevent:
+ *
+ * ```tsx
+ * const { host, surfaces } = useInteractionHosts();
+ * const dispatcher = useMemo(() => createBrowserDispatcher({ ...host, executeCommand, navigate }), [host]);
+ *
+ * return <InteractionScope dispatcher={dispatcher}>{children}{surfaces}</InteractionScope>;
+ * ```
+ *
+ * An application with a design system of its own passes its own `notify` after the spread and keeps the rest.
+ * @param options The {@link InteractionHostOptions}.
+ * @returns The {@link InteractionHosts}.
+ */ function useInteractionHosts(options = {}) {
+    const { dismissAfter = 6000 } = options;
+    const [notifications, setNotifications] = useState([]);
+    const [unresolved, setUnresolved] = useState([]);
+    const [request, setRequest] = useState(undefined);
+    const nextId = useRef(0);
+    const dismiss = useCallback((id)=>setNotifications((current)=>current.filter((_)=>_.id !== id)), []);
+    const notify = useCallback((level, message)=>{
+        const id = nextId.current++;
+        setNotifications((current)=>[
+                ...current,
+                {
+                    id,
+                    level,
+                    message
+                }
+            ]);
+        if (dismissAfter > 0) {
+            setTimeout(()=>setNotifications((current)=>current.filter((_)=>_.id !== id)), dismissAfter);
+        }
+    }, [
+        dismissAfter
+    ]);
+    const confirm = useCallback((message)=>new Promise((resolve)=>{
+            setRequest({
+                message,
+                answer (confirmed) {
+                    // Cleared before resolving, so the sequence that continues cannot find a question on screen
+                    // that has already been answered.
+                    setRequest(undefined);
+                    resolve(confirmed);
+                }
+            });
+        }), []);
+    const onUnsupported = useCallback((action)=>{
+        // Reported once per distinct action. An unsupported action on a hover or an interval would otherwise
+        // grow the list until it covered the application it is trying to tell you about.
+        setUnresolved((current)=>current.some((_)=>_.action === action) ? current : [
+                ...current,
+                {
+                    id: nextId.current++,
+                    action
+                }
+            ]);
+    }, []);
+    const host = useMemo(()=>({
+            notify,
+            confirm,
+            onUnsupported
+        }), [
+        notify,
+        confirm,
+        onUnsupported
+    ]);
+    const surfaces = useMemo(()=>/*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(NotificationHost, {
+                    notifications: notifications,
+                    onDismiss: dismiss
+                }),
+                /*#__PURE__*/ jsx(ConfirmHost, {
+                    request: request
+                }),
+                /*#__PURE__*/ jsx(UnresolvedActionHost, {
+                    unresolved: unresolved
+                })
+            ]
+        }), [
+        notifications,
+        dismiss,
+        request,
+        unresolved
+    ]);
+    return {
+        host,
+        surfaces
+    };
+}
+
+export { useInteractionHosts };
+//# sourceMappingURL=useInteractionHosts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionHosts.js","sources":["../../../interactions/useInteractionHosts.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, useCallback, useMemo, useRef, useState } from 'react';\nimport { NotificationLevel } from '@cratis/scene.model';\nimport { BrowserDispatcherHost } from './createBrowserDispatcher';\nimport { ConfirmHost } from './ConfirmHost';\nimport { ConfirmRequest } from './ConfirmRequest';\nimport { NotificationHost } from './NotificationHost';\nimport { SceneNotification } from './SceneNotification';\nimport { UnresolvedAction } from './UnresolvedAction';\nimport { UnresolvedActionHost } from './UnresolvedActionHost';\n\n/**\n * What {@link useInteractionHosts} gives an application.\n */\nexport interface InteractionHosts {\n    /** The parts of a {@link BrowserDispatcherHost} these surfaces provide. Spread it into the host you build. */\n    readonly host: Pick<BrowserDispatcherHost, 'notify' | 'confirm' | 'onUnsupported'>;\n\n    /** The surfaces themselves. Render them once, anywhere inside the application. */\n    readonly surfaces: ReactNode;\n}\n\n/**\n * How long a notification stays before it removes itself, in milliseconds.\n */\nexport interface InteractionHostOptions {\n    /** How long a notification stays up. `0` keeps it until it is dismissed. */\n    readonly dismissAfter?: number;\n}\n\n/**\n * Provides the default surfaces for the actions that need somewhere to appear.\n *\n * `notify` and `confirm` are the two actions a document can take that have no backend and no route: they are\n * purely things the user sees. Without a surface, a host either invents one or the action goes to the console,\n * which is why these ship with Scene rather than being every application's first chore.\n *\n * The three are returned as one unit because they are wired the same way and forgetting to render one of them\n * is exactly the failure they exist to prevent:\n *\n * ```tsx\n * const { host, surfaces } = useInteractionHosts();\n * const dispatcher = useMemo(() => createBrowserDispatcher({ ...host, executeCommand, navigate }), [host]);\n *\n * return <InteractionScope dispatcher={dispatcher}>{children}{surfaces}</InteractionScope>;\n * ```\n *\n * An application with a design system of its own passes its own `notify` after the spread and keeps the rest.\n * @param options The {@link InteractionHostOptions}.\n * @returns The {@link InteractionHosts}.\n */\nexport function useInteractionHosts(options: InteractionHostOptions = {}): InteractionHosts {\n    const { dismissAfter = 6000 } = options;\n    const [notifications, setNotifications] = useState<readonly SceneNotification[]>([]);\n    const [unresolved, setUnresolved] = useState<readonly UnresolvedAction[]>([]);\n    const [request, setRequest] = useState<ConfirmRequest | undefined>(undefined);\n    const nextId = useRef(0);\n\n    const dismiss = useCallback((id: number) => setNotifications(current => current.filter(_ => _.id !== id)), []);\n\n    const notify = useCallback((level: NotificationLevel, message: string) => {\n        const id = nextId.current++;\n        setNotifications(current => [...current, { id, level, message }]);\n\n        if (dismissAfter > 0) {\n            setTimeout(() => setNotifications(current => current.filter(_ => _.id !== id)), dismissAfter);\n        }\n    }, [dismissAfter]);\n\n    const confirm = useCallback((message: string) => new Promise<boolean>(resolve => {\n        setRequest({\n            message,\n            answer(confirmed) {\n                // Cleared before resolving, so the sequence that continues cannot find a question on screen\n                // that has already been answered.\n                setRequest(undefined);\n                resolve(confirmed);\n            },\n        });\n    }), []);\n\n    const onUnsupported = useCallback((action: string) => {\n        // Reported once per distinct action. An unsupported action on a hover or an interval would otherwise\n        // grow the list until it covered the application it is trying to tell you about.\n        setUnresolved(current => current.some(_ => _.action === action) ? current : [...current, { id: nextId.current++, action }]);\n    }, []);\n\n    const host = useMemo(() => ({ notify, confirm, onUnsupported }), [notify, confirm, onUnsupported]);\n\n    const surfaces = useMemo(() => (\n        <>\n            <NotificationHost notifications={notifications} onDismiss={dismiss} />\n            <ConfirmHost request={request} />\n            <UnresolvedActionHost unresolved={unresolved} />\n        </>\n    ), [notifications, dismiss, request, unresolved]);\n\n    return { host, surfaces };\n}\n"],"names":["useInteractionHosts","options","dismissAfter","notifications","setNotifications","useState","unresolved","setUnresolved","request","setRequest","undefined","nextId","useRef","dismiss","useCallback","id","current","filter","_","notify","level","message","setTimeout","confirm","Promise","resolve","answer","confirmed","onUnsupported","action","some","host","useMemo","surfaces","_jsxs","_Fragment","_jsx","NotificationHost","onDismiss","ConfirmHost","UnresolvedActionHost"],"mappings":"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"}

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":";;;;;AAAA;AACA;AAsBA,MAAMA,WAAAA,GAAqE;AACvE,IAAA;AAAC,QAAA,SAAA;AAAWC,QAAAA,sBAAAA,CAAuBC;AAAM,KAAA;AACzC,IAAA;AAAC,QAAA,eAAA;AAAiBD,QAAAA,sBAAAA,CAAuBE;AAAY,KAAA;AACrD,IAAA;AAAC,QAAA,UAAA;AAAYF,QAAAA,sBAAAA,CAAuBG;AAAO,KAAA;AAC3C,IAAA;AAAC,QAAA,UAAA;AAAYH,QAAAA,sBAAAA,CAAuBI;AAAO,KAAA;AAC3C,IAAA;AAAC,QAAA,UAAA;AAAYJ,QAAAA,sBAAAA,CAAuBK;AAAO;AAC9C,CAAA;AAED;;;;;;;;;;;;;;;AAeC,IACM,SAASC,eAAAA,CAAgBC,KAAa,EAAEC,SAAsB,EAAA;AACjE,IAAA,MAAMC,KAAAA,GAAQC,mBAAAA,EAAAA;IAEd,MAAMC,WAAAA,GAAcC,QAChB,IAAM;AAAKH,YAAAA,GAAAA,KAAAA,EAAOE,eAAe,EAAE;AAAME,YAAAA,GAAAA,aAAAA,CAAcN,KAAAA,EAAOC,SAAAA;SAAW,EACzE;AAACC,QAAAA,KAAAA;AAAOF,QAAAA,KAAAA;AAAOC,QAAAA;AAAU,KAAA,CAAA;IAE7B,MAAMM,GAAAA,GAAMC,YAAY,OAAOC,IAAAA,GAAAA;AAC3B,QAAA,IAAI,CAACP,KAAAA,EAAO;QAEZ,MAAMQ,MAAAA,GAAS,MAAMC,WAAAA,CAAYC,gBAAAA,CAAiBR,WAAAA,EAAaK,OAAOP,KAAAA,CAAMW,UAAU,EAAEX,KAAAA,CAAMY,OAAO,CAAA;QACrG,IAAIJ,MAAAA,CAAOK,QAAQ,CAACC,MAAM,GAAG,GAAGd,KAAAA,CAAMe,UAAU,GAAGP,MAAAA,CAAOK,QAAQ,CAAA;IACtE,CAAA,EAAG;AAACb,QAAAA,KAAAA;AAAOE,QAAAA;AAAY,KAAA,CAAA;;;;IAKvBc,SAAAA,CAAU,IAAA;QACN,KAAKX,GAAAA,CAAId,uBAAuB0B,IAAI,CAAA;QACpC,KAAKZ,GAAAA,CAAId,uBAAuB2B,KAAK,CAAA;QAErC,OAAO,IAAA;YACH,KAAKb,GAAAA,CAAId,uBAAuB4B,MAAM,CAAA;YACtC,KAAKd,GAAAA,CAAId,uBAAuB6B,KAAK,CAAA;AACzC,QAAA,CAAA;IACJ,CAAA,EAAG;AAACf,QAAAA;AAAI,KAAA,CAAA;IAERW,SAAAA,CAAU,IAAA;AACN,QAAA,MAAMK,YAAYC,wBAAAA,CAAyBpB,WAAAA,CAAAA;AAC3C,QAAA,IAAImB,SAAAA,CAAUP,MAAM,KAAK,CAAA,IAAK,CAACd,KAAAA,EAAO;AAEtC,QAAA,MAAMuB,MAAAA,GAASF,SAAAA,CAAUG,GAAG,CAACC,CAAAA,SAAAA,GAAAA;YACzB,MAAMC,OAAAA,GAAU,SAACD,CAAUE,OAAO,CAACC,OAAO,CAA0BF,OAAO,IAAI,CAAA;YAC/E,OAAOG,WAAAA,CACH,IAAM,KAAKpB,WAAAA,CAAY;AAACgB,oBAAAA;iBAAU,EAAEzB,KAAAA,CAAMW,UAAU,EAAEX,KAAAA,CAAMY,OAAO,GACnEkB,IAAAA,CAAKC,GAAG,CAACL,OAAAA,EAAS,CAAA,CAAA,GAAK,IAAA,CAAA;AAC/B,QAAA,CAAA,CAAA;QAEA,OAAO,IAAMH,MAAAA,CAAOS,OAAO,CAACC,aAAAA,CAAAA;IAChC,CAAA,EAAG;AAAC/B,QAAAA,WAAAA;AAAaF,QAAAA;AAAM,KAAA,CAAA;AAEvB,IAAA,OAAOG,OAAAA,CAAQ,IAAA;AACX,QAAA,MAAM+B,WAAgC,EAAC;QACvC,IAAI,CAAClC,OAAO,OAAOkC,QAAAA;AAEnB,QAAA,KAAK,MAAM,CAACC,OAAAA,EAAS5B,IAAAA,CAAK,IAAIjB,WAAAA,CAAa;;;AAGvC,YAAA,IAAIoB,gBAAAA,CAAiBR,WAAAA,EAAaK,IAAAA,CAAAA,CAAMO,MAAM,KAAK,CAAA,EAAG;AAEtD,YAAA,IAAIqB,YAAY,UAAA,EAAY;gBACxBD,QAAAA,CAASE,QAAQ,GAAGC,CAAAA,KAAAA,GAAAA;AAChBA,oBAAAA,KAAAA,CAAMC,cAAc,EAAA;AACpB,oBAAA,KAAKjC,GAAAA,CAAIE,IAAAA,CAAAA;AACb,gBAAA,CAAA;AACA,gBAAA;AACJ,YAAA;YAEA2B,QAAQ,CAACC,OAAAA,CAAQ,GAAI,CAACE,KAAAA,GAAAA;;;gBAGlBA,KAAAA,EAAOE,eAAAA,EAAAA;AACP,gBAAA,KAAKlC,GAAAA,CAAIE,IAAAA,CAAAA;AACb,YAAA,CAAA;AACJ,QAAA;QAEA,OAAO2B,QAAAA;IACX,CAAA,EAAG;AAAClC,QAAAA,KAAAA;AAAOE,QAAAA,WAAAA;AAAaG,QAAAA;AAAI,KAAA,CAAA;AAChC;;"}

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,24 @@
+import { createElement } from 'react';
+import 'react/jsx-runtime';
+import { useInteractions } from '../interactions/useInteractions.js';
+import '../interactions/NotificationHost.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;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createReactRenderer.d.ts","sourceRoot":"","sources":["../../../renderer/createReactRenderer.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAiB,MAAM,OAAO,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAYxD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,QAAQ,CAAC,SAAS,CAAC,CAgCpF"}
+{"version":3,"file":"createReactRenderer.d.ts","sourceRoot":"","sources":["../../../renderer/createReactRenderer.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAiB,MAAM,OAAO,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAaxD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,QAAQ,CAAC,SAAS,CAAC,CAgCpF"}

package/dist/esm/renderer/createReactRenderer.js

@@ -1,4 +1,5 @@
 import { createElement } from 'react';
+import { InteractiveComponent } from './InteractiveComponent.js';
 import { childStyle, panelStyle } from './panelLayout.js';
 import { UnresolvedComponent } from './UnresolvedComponent.js';
 
@@ -29,8 +30,9 @@ import { UnresolvedComponent } from './UnresolvedComponent.js';
         },
         renderExternalComponent (element, slots) {
             const Component = registry[element.componentName] ?? UnresolvedComponent;
-            return /*#__PURE__*/ createElement(Component, {
+            return /*#__PURE__*/ createElement(InteractiveComponent, {
                 key: element.id,
+                component: Component,
                 element,
                 slots
             });

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

@@ -1 +1 @@
-{"version":3,"file":"createReactRenderer.js","sources":["../../../renderer/createReactRenderer.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, createElement } from 'react';\nimport { Renderer } from '@cratis/scene.engine';\nimport { ContentControl, ExternalComponent, ItemsControl, Panel } from '@cratis/scene.model';\nimport { ComponentRegistry } from './ComponentRegistry';\nimport { childStyle, panelStyle } from './panelLayout';\nimport { UnresolvedComponent } from './UnresolvedComponent';\n\n/**\n * Creates a {@link Renderer} that turns a Scene element tree into React elements.\n *\n * `ItemsControl` and `ContentControl` render as plain wrapping `div`s. A `Panel` renders as the\n * arrangement it declares - a grid, a stack, a wrap or a dock - because that is what those panels are\n * for; see `panelLayout` for the mapping. Arranging a *layout's slots* by `flow`/`freeform` is a\n * different thing and stays Scene#4's, layered on top of this renderer rather than folded into it.\n */\nexport function createReactRenderer(registry: ComponentRegistry): Renderer<ReactNode> {\n    return {\n        renderContentControl(element: ContentControl, content: ReactNode): ReactNode {\n            return createElement('div', { key: element.id, 'data-scene-id': element.id, 'data-scene-kind': 'ContentControl' }, content);\n        },\n\n        renderItemsControl(element: ItemsControl, items: ReactNode[]): ReactNode {\n            return createElement('div', { key: element.id, 'data-scene-id': element.id, 'data-scene-kind': 'ItemsControl' }, items);\n        },\n\n        renderExternalComponent(element: ExternalComponent, slots: Record<string, ReactNode[]>): ReactNode {\n            const Component = registry[element.componentName] ?? UnresolvedComponent;\n            return createElement(Component, { key: element.id, element, slots });\n        },\n\n        renderPanel(element: Panel, children: ReactNode[]): ReactNode {\n            // The rendered children arrive in the same order as `element.children`, so a panel that places\n            // its children individually - a grid cell, a docked edge - can wrap each one in the box that\n            // places it without needing to re-render anything.\n            const placed = children.map((child, index) => {\n                const style = childStyle(element, element.children[index], index);\n                return style\n                    ? createElement('div', { key: `${element.id}-${index}`, 'data-scene-placement': index, style }, child)\n                    : child;\n            });\n\n            return createElement(\n                'div',\n                { key: element.id, 'data-scene-id': element.id, 'data-scene-kind': 'Panel', style: panelStyle(element) },\n                placed);\n        },\n    };\n}\n"],"names":["createReactRenderer","registry","renderContentControl","element","content","createElement","key","id","renderItemsControl","items","renderExternalComponent","slots","Component","componentName","UnresolvedComponent","renderPanel","children","placed","map","child","index","style","childStyle","panelStyle"],"mappings":";;;;AAAA;AACA;AASA;;;;;;;IAQO,SAASA,mBAAAA,CAAoBC,QAA2B,EAAA;IAC3D,OAAO;QACHC,oBAAAA,CAAAA,CAAqBC,OAAuB,EAAEC,OAAkB,EAAA;AAC5D,YAAA,qBAAOC,cAAc,KAAA,EAAO;AAAEC,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;AAAE,gBAAA,eAAA,EAAiBJ,QAAQI,EAAE;gBAAE,iBAAA,EAAmB;aAAiB,EAAGH,OAAAA,CAAAA;AACvH,QAAA,CAAA;QAEAI,kBAAAA,CAAAA,CAAmBL,OAAqB,EAAEM,KAAkB,EAAA;AACxD,YAAA,qBAAOJ,cAAc,KAAA,EAAO;AAAEC,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;AAAE,gBAAA,eAAA,EAAiBJ,QAAQI,EAAE;gBAAE,iBAAA,EAAmB;aAAe,EAAGE,KAAAA,CAAAA;AACrH,QAAA,CAAA;QAEAC,uBAAAA,CAAAA,CAAwBP,OAA0B,EAAEQ,KAAkC,EAAA;AAClF,YAAA,MAAMC,YAAYX,QAAQ,CAACE,OAAAA,CAAQU,aAAa,CAAC,IAAIC,mBAAAA;AACrD,YAAA,qBAAOT,cAAcO,SAAAA,EAAW;AAAEN,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;AAAEJ,gBAAAA,OAAAA;AAASQ,gBAAAA;AAAM,aAAA,CAAA;AACtE,QAAA,CAAA;QAEAI,WAAAA,CAAAA,CAAYZ,OAAc,EAAEa,QAAqB,EAAA;;;;AAI7C,YAAA,MAAMC,MAAAA,GAASD,QAAAA,CAASE,GAAG,CAAC,CAACC,KAAAA,EAAOC,KAAAA,GAAAA;AAChC,gBAAA,MAAMC,QAAQC,UAAAA,CAAWnB,OAAAA,EAASA,QAAQa,QAAQ,CAACI,MAAM,EAAEA,KAAAA,CAAAA;gBAC3D,OAAOC,KAAAA,iBACDhB,cAAc,KAAA,EAAO;AAAEC,oBAAAA,GAAAA,EAAK,GAAGH,OAAAA,CAAQI,EAAE,CAAC,CAAC,EAAEa,KAAAA,CAAAA,CAAO;oBAAE,sBAAA,EAAwBA,KAAAA;AAAOC,oBAAAA;AAAM,iBAAA,EAAGF,KAAAA,CAAAA,GAC9FA,KAAAA;AACV,YAAA,CAAA,CAAA;AAEA,YAAA,qBAAOd,cACH,KAAA,EACA;AAAEC,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;AAAE,gBAAA,eAAA,EAAiBJ,QAAQI,EAAE;gBAAE,iBAAA,EAAmB,OAAA;AAASc,gBAAAA,KAAAA,EAAOE,UAAAA,CAAWpB,OAAAA;aAAS,EACvGc,MAAAA,CAAAA;AACR,QAAA;AACJ,KAAA;AACJ;;"}
+{"version":3,"file":"createReactRenderer.js","sources":["../../../renderer/createReactRenderer.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, createElement } from 'react';\nimport { Renderer } from '@cratis/scene.engine';\nimport { ContentControl, ExternalComponent, ItemsControl, Panel } from '@cratis/scene.model';\nimport { ComponentRegistry } from './ComponentRegistry';\nimport { InteractiveComponent } from './InteractiveComponent';\nimport { childStyle, panelStyle } from './panelLayout';\nimport { UnresolvedComponent } from './UnresolvedComponent';\n\n/**\n * Creates a {@link Renderer} that turns a Scene element tree into React elements.\n *\n * `ItemsControl` and `ContentControl` render as plain wrapping `div`s. A `Panel` renders as the\n * arrangement it declares - a grid, a stack, a wrap or a dock - because that is what those panels are\n * for; see `panelLayout` for the mapping. Arranging a *layout's slots* by `flow`/`freeform` is a\n * different thing and stays Scene#4's, layered on top of this renderer rather than folded into it.\n */\nexport function createReactRenderer(registry: ComponentRegistry): Renderer<ReactNode> {\n    return {\n        renderContentControl(element: ContentControl, content: ReactNode): ReactNode {\n            return createElement('div', { key: element.id, 'data-scene-id': element.id, 'data-scene-kind': 'ContentControl' }, content);\n        },\n\n        renderItemsControl(element: ItemsControl, items: ReactNode[]): ReactNode {\n            return createElement('div', { key: element.id, 'data-scene-id': element.id, 'data-scene-kind': 'ItemsControl' }, items);\n        },\n\n        renderExternalComponent(element: ExternalComponent, slots: Record<string, ReactNode[]>): ReactNode {\n            const Component = registry[element.componentName] ?? UnresolvedComponent;\n            return createElement(InteractiveComponent, { key: element.id, component: Component, element, slots });\n        },\n\n        renderPanel(element: Panel, children: ReactNode[]): ReactNode {\n            // The rendered children arrive in the same order as `element.children`, so a panel that places\n            // its children individually - a grid cell, a docked edge - can wrap each one in the box that\n            // places it without needing to re-render anything.\n            const placed = children.map((child, index) => {\n                const style = childStyle(element, element.children[index], index);\n                return style\n                    ? createElement('div', { key: `${element.id}-${index}`, 'data-scene-placement': index, style }, child)\n                    : child;\n            });\n\n            return createElement(\n                'div',\n                { key: element.id, 'data-scene-id': element.id, 'data-scene-kind': 'Panel', style: panelStyle(element) },\n                placed);\n        },\n    };\n}\n"],"names":["createReactRenderer","registry","renderContentControl","element","content","createElement","key","id","renderItemsControl","items","renderExternalComponent","slots","Component","componentName","UnresolvedComponent","InteractiveComponent","component","renderPanel","children","placed","map","child","index","style","childStyle","panelStyle"],"mappings":";;;;;AAAA;AACA;AAUA;;;;;;;IAQO,SAASA,mBAAAA,CAAoBC,QAA2B,EAAA;IAC3D,OAAO;QACHC,oBAAAA,CAAAA,CAAqBC,OAAuB,EAAEC,OAAkB,EAAA;AAC5D,YAAA,qBAAOC,cAAc,KAAA,EAAO;AAAEC,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;AAAE,gBAAA,eAAA,EAAiBJ,QAAQI,EAAE;gBAAE,iBAAA,EAAmB;aAAiB,EAAGH,OAAAA,CAAAA;AACvH,QAAA,CAAA;QAEAI,kBAAAA,CAAAA,CAAmBL,OAAqB,EAAEM,KAAkB,EAAA;AACxD,YAAA,qBAAOJ,cAAc,KAAA,EAAO;AAAEC,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;AAAE,gBAAA,eAAA,EAAiBJ,QAAQI,EAAE;gBAAE,iBAAA,EAAmB;aAAe,EAAGE,KAAAA,CAAAA;AACrH,QAAA,CAAA;QAEAC,uBAAAA,CAAAA,CAAwBP,OAA0B,EAAEQ,KAAkC,EAAA;AAClF,YAAA,MAAMC,YAAYX,QAAQ,CAACE,OAAAA,CAAQU,aAAa,CAAC,IAAIC,mBAAAA;AACrD,YAAA,qBAAOT,cAAcU,oBAAAA,EAAsB;AAAET,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;gBAAES,SAAAA,EAAWJ,SAAAA;AAAWT,gBAAAA,OAAAA;AAASQ,gBAAAA;AAAM,aAAA,CAAA;AACvG,QAAA,CAAA;QAEAM,WAAAA,CAAAA,CAAYd,OAAc,EAAEe,QAAqB,EAAA;;;;AAI7C,YAAA,MAAMC,MAAAA,GAASD,QAAAA,CAASE,GAAG,CAAC,CAACC,KAAAA,EAAOC,KAAAA,GAAAA;AAChC,gBAAA,MAAMC,QAAQC,UAAAA,CAAWrB,OAAAA,EAASA,QAAQe,QAAQ,CAACI,MAAM,EAAEA,KAAAA,CAAAA;gBAC3D,OAAOC,KAAAA,iBACDlB,cAAc,KAAA,EAAO;AAAEC,oBAAAA,GAAAA,EAAK,GAAGH,OAAAA,CAAQI,EAAE,CAAC,CAAC,EAAEe,KAAAA,CAAAA,CAAO;oBAAE,sBAAA,EAAwBA,KAAAA;AAAOC,oBAAAA;AAAM,iBAAA,EAAGF,KAAAA,CAAAA,GAC9FA,KAAAA;AACV,YAAA,CAAA,CAAA;AAEA,YAAA,qBAAOhB,cACH,KAAA,EACA;AAAEC,gBAAAA,GAAAA,EAAKH,QAAQI,EAAE;AAAE,gBAAA,eAAA,EAAiBJ,QAAQI,EAAE;gBAAE,iBAAA,EAAmB,OAAA;AAASgB,gBAAAA,KAAAA,EAAOE,UAAAA,CAAWtB,OAAAA;aAAS,EACvGgB,MAAAA,CAAAA;AACR,QAAA;AACJ,KAAA;AACJ;;"}

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

@@ -1,4 +1,5 @@
 export * from './ComponentRegistry';
 export * from './UnresolvedComponent';
 export * from './createReactRenderer';
+export * from './InteractiveComponent';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../renderer/index.ts"],"names":[],"mappings":"AAGA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../renderer/index.ts"],"names":[],"mappings":"AAGA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/dist/esm/renderer/index.js

@@ -1,4 +1,5 @@
 export * from './ComponentRegistry';
 export * from './UnresolvedComponent';
 export * from './createReactRenderer';
+export * from './InteractiveComponent';
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../renderer/index.ts"],"names":[],"mappings":"AAGA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../renderer/index.ts"],"names":[],"mappings":"AAGA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}