@dxos/plugin-client 0.7.4-staging.f7e8224 → 0.7.5-main.499c70c

package/dist/lib/node-esm/index.mjs

@@ -1,65 +1,57 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ClientAction
+} from "./chunk-TI4GNGMM.mjs";
 import {
   CLIENT_PLUGIN,
-  ClientAction,
-  OBSERVABILITY_ACTION,
   meta_default
-} from "./chunk-C6X363FK.mjs";
+} from "./chunk-GMGRQ5Q7.mjs";
 
 // packages/plugins/plugin-client/src/ClientPlugin.tsx
 import React4 from "react";
-import { LayoutAction as LayoutAction3, parseIntentPlugin, resolvePlugin } from "@dxos/app-framework";
+import { LayoutAction as LayoutAction3, parseIntentPlugin, resolvePlugin, createSurface, createIntent as createIntent3, createResolver } from "@dxos/app-framework";
 import { Config, Defaults, Envs, Local, Storage } from "@dxos/config";
 import { registerSignalsRuntime } from "@dxos/echo-signals/react";
 import { invariant } from "@dxos/invariant";
 import { createExtension } from "@dxos/plugin-graph";
+import { ObservabilityAction as ObservabilityAction2 } from "@dxos/plugin-observability/types";
 import { Client, ClientProvider } from "@dxos/react-client";
 
 // packages/plugins/plugin-client/src/components/IdentityDialog.tsx
 import React, { useCallback } from "react";
-import { LayoutAction, useIntentDispatcher } from "@dxos/app-framework";
+import { createIntent, LayoutAction, useIntentDispatcher } from "@dxos/app-framework";
 import { useClient } from "@dxos/react-client";
 import { Clipboard, Dialog } from "@dxos/react-ui";
 import { IdentityPanel } from "@dxos/shell/react";
+var IDENTITY_DIALOG = `${CLIENT_PLUGIN}/IdentityDialog`;
 var IdentityDialog = (props) => {
-  const dispatch = useIntentDispatcher();
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
   const client = useClient();
-  const handleDone = useCallback(() => dispatch({
-    action: LayoutAction.SET_LAYOUT,
-    data: {
-      element: "dialog",
-      state: false
-    }
-  }), [
+  const handleDone = useCallback(() => dispatch(createIntent(LayoutAction.SetLayout, {
+    element: "dialog",
+    state: false
+  })), [
     dispatch
   ]);
   const handleResetStorage = useCallback(async () => {
     await client.reset();
-    await dispatch({
-      action: ClientAction.RESET_STORAGE
-    });
+    await dispatch(createIntent(ClientAction.ResetStorage));
   }, [
     dispatch
   ]);
   const handleRecover = useCallback(async () => {
     await client.reset();
-    await dispatch({
-      action: ClientAction.RESET_STORAGE,
-      data: {
-        target: "recoverIdentity"
-      }
-    });
+    await dispatch(createIntent(ClientAction.ResetStorage, {
+      target: "recoverIdentity"
+    }));
   }, [
     dispatch
   ]);
   const handleJoinNewIdentity = useCallback(async () => {
     await client.reset();
-    await dispatch({
-      action: ClientAction.RESET_STORAGE,
-      data: {
-        target: "deviceInvitation"
-      }
-    });
+    await dispatch(createIntent(ClientAction.ResetStorage, {
+      target: "deviceInvitation"
+    }));
   }, [
     dispatch
   ]);
@@ -77,33 +69,26 @@ var IdentityDialog = (props) => {
 
 // packages/plugins/plugin-client/src/components/JoinDialog.tsx
 import React2, { useCallback as useCallback2 } from "react";
-import { LayoutAction as LayoutAction2, useIntentDispatcher as useIntentDispatcher2 } from "@dxos/app-framework";
+import { createIntent as createIntent2, LayoutAction as LayoutAction2, useIntentDispatcher as useIntentDispatcher2 } from "@dxos/app-framework";
+import { ObservabilityAction } from "@dxos/plugin-observability/types";
 import { Dialog as Dialog2 } from "@dxos/react-ui";
 import { JoinPanel } from "@dxos/shell/react";
+var JOIN_DIALOG = `${CLIENT_PLUGIN}/JoinDialog`;
 var JoinDialog = (props) => {
-  const dispatch = useIntentDispatcher2();
-  const handleCancelResetStorage = useCallback2(() => dispatch({
-    plugin: CLIENT_PLUGIN,
-    action: ClientAction.SHARE_IDENTITY
-  }), [
+  const { dispatchPromise: dispatch } = useIntentDispatcher2();
+  const handleCancelResetStorage = useCallback2(() => dispatch(createIntent2(ClientAction.ShareIdentity)), [
     dispatch
   ]);
   const handleDone = useCallback2(async (result) => {
     if (result?.identityKey) {
       await Promise.all([
-        dispatch({
-          action: LayoutAction2.SET_LAYOUT,
-          data: {
-            element: "dialog",
-            state: false
-          }
-        }),
-        dispatch({
-          action: OBSERVABILITY_ACTION,
-          data: {
-            name: props.initialDisposition === "recover-identity" ? "identity.recover" : "identity.join"
-          }
-        })
+        dispatch(createIntent2(LayoutAction2.SetLayout, {
+          element: "dialog",
+          state: false
+        })),
+        dispatch(createIntent2(ObservabilityAction.SendEvent, {
+          name: props.initialDisposition === "recover-identity" ? "identity.recover" : "identity.join"
+        }))
       ]);
     }
   }, [
@@ -126,21 +111,20 @@ var JoinDialog = (props) => {
 // packages/plugins/plugin-client/src/components/RecoveryCodeDialog.tsx
 import React3, { useCallback as useCallback3, useState } from "react";
 import { AlertDialog, Button, Clipboard as Clipboard2, Input, useTranslation } from "@dxos/react-ui";
+var RECOVER_CODE_DIALOG = `${CLIENT_PLUGIN}/RecoveryCodeDialog`;
 var RecoveryCodeDialog = ({ code }) => {
   const { t } = useTranslation(CLIENT_PLUGIN);
   const [confirmation, setConfirmation] = useState(false);
   const handleConfirmation = useCallback3((checked) => setConfirmation(checked), []);
   return /* @__PURE__ */ React3.createElement(AlertDialog.Content, {
     classNames: "bs-content min-bs-[15rem] max-bs-full md:max-is-[40rem] overflow-hidden"
-  }, /* @__PURE__ */ React3.createElement(AlertDialog.Title, {
-    classNames: ""
-  }, t("recovery code dialog title")), /* @__PURE__ */ React3.createElement("p", {
+  }, /* @__PURE__ */ React3.createElement(AlertDialog.Title, null, t("recovery code dialog title")), /* @__PURE__ */ React3.createElement("p", {
     className: "py-4"
   }, t("recovery code dialog description")), /* @__PURE__ */ React3.createElement(Clipboard2.Provider, null, /* @__PURE__ */ React3.createElement(Code, {
-    value: code
-  })), /* @__PURE__ */ React3.createElement("p", {
-    className: "py-4"
-  }, t("recovery code dialog warning")), /* @__PURE__ */ React3.createElement("div", {
+    code
+  })), /* @__PURE__ */ React3.createElement("div", {
+    className: "flex flex-col py-4 gap-2"
+  }, /* @__PURE__ */ React3.createElement("p", null, t("recovery code dialog warning 1")), /* @__PURE__ */ React3.createElement("p", null, t("recovery code dialog warning 2"))), /* @__PURE__ */ React3.createElement("div", {
     className: "flex items-center gap-2 pbe-4"
   }, /* @__PURE__ */ React3.createElement(Input.Root, null, /* @__PURE__ */ React3.createElement(Input.Checkbox, {
     "data-testid": "recoveryCode.confirm",
@@ -156,15 +140,23 @@ var RecoveryCodeDialog = ({ code }) => {
     disabled: !confirmation
   }, t("continue label")))));
 };
-var Code = ({ value }) => {
+var Code = ({ code }) => {
+  const words = code.split(" ");
   return /* @__PURE__ */ React3.createElement("div", {
     className: "relative p-2 border border-separator rounded group"
   }, /* @__PURE__ */ React3.createElement(Clipboard2.IconButton, {
-    value,
+    value: code,
     classNames: "absolute top-2 right-2 invisible group-hover:visible"
-  }), /* @__PURE__ */ React3.createElement("code", {
-    className: "whitespace-pre-wrap"
-  }, value));
+  }), /* @__PURE__ */ React3.createElement("div", {
+    className: "grid grid-cols-4"
+  }, words.map((word, i) => /* @__PURE__ */ React3.createElement("div", {
+    key: i,
+    className: "flex items-center p-2 gap-2 items-center"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "w-4 text-xs text-center text-subdued"
+  }, i + 1), /* @__PURE__ */ React3.createElement("div", {
+    className: "text-sm"
+  }, word)))));
 };
 
 // packages/plugins/plugin-client/src/translations.ts
@@ -173,10 +165,11 @@ var translations_default = [
     "en-US": {
       [CLIENT_PLUGIN]: {
         "open shell label": "Open HALO",
-        "recovery code dialog title": "Recovery Code",
+        "recovery code dialog title": "Account Recovery",
         "recovery code dialog description": "This is your identity recovery code, store it in a safe place. You can use it to recover your identity if you ever lose access to your devices.",
-        "recovery code dialog warning": "Please note: This code will not be displayed again and cannot be replaced. It is your private key for recovering DXOS data. Anyone with this key will also be able to gain access to your account.",
-        "recovery code confirmation label": "Confirm the code has been saved",
+        "recovery code dialog warning 1": "NOTE: This code will not be displayed again.",
+        "recovery code dialog warning 2": "It is your private key for recovering DXOS data. Anyone with this key will be able to gain access to your account.",
+        "recovery code confirmation label": "Please confirm you have saved the code.",
         "continue label": "Continue"
       }
     }
@@ -185,7 +178,6 @@ var translations_default = [
 
 // packages/plugins/plugin-client/src/ClientPlugin.tsx
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-client/src/ClientPlugin.tsx";
-var parseClientPlugin = (plugin) => (plugin?.provides).client instanceof Client ? plugin : void 0;
 var ClientPlugin = ({ appKey, invitationUrl = window.location.origin, invitationParam = "deviceInvitationCode", onClientInitialized, onReady, onReset, ...options }) => {
   registerSignalsRuntime();
   let client;
@@ -223,7 +215,7 @@ var ClientPlugin = ({ appKey, invitationUrl = window.location.origin, invitation
         }, children)
       };
     },
-    ready: async (plugins) => {
+    ready: async ({ plugins }) => {
       if (error) {
         throw error;
       }
@@ -235,27 +227,33 @@ var ClientPlugin = ({ appKey, invitationUrl = window.location.origin, invitation
     provides: {
       translations: translations_default,
       surface: {
-        component: ({ data, role, ...rest }) => {
-          switch (role) {
-            case "dialog":
-              if (data.component === "dxos.org/plugin/client/IdentityDialog") {
-                return /* @__PURE__ */ React4.createElement(IdentityDialog, {
-                  ...data.subject,
-                  createInvitationUrl: createDeviceInvitationUrl
-                });
-              } else if (data.component === "dxos.org/plugin/client/JoinDialog") {
-                return /* @__PURE__ */ React4.createElement(JoinDialog, data.subject);
-              } else if (data.component === "dxos.org/plugin/client/RecoveryCodeDialog") {
-                return /* @__PURE__ */ React4.createElement(RecoveryCodeDialog, data.subject);
-              }
-              break;
-          }
-          return null;
-        }
+        definitions: () => [
+          createSurface({
+            id: IDENTITY_DIALOG,
+            role: "dialog",
+            filter: (data) => data.component === IDENTITY_DIALOG,
+            component: ({ data }) => /* @__PURE__ */ React4.createElement(IdentityDialog, {
+              ...data.subject,
+              createInvitationUrl: createDeviceInvitationUrl
+            })
+          }),
+          createSurface({
+            id: JOIN_DIALOG,
+            role: "dialog",
+            filter: (data) => data.component === JOIN_DIALOG,
+            component: ({ data }) => /* @__PURE__ */ React4.createElement(JoinDialog, data.subject)
+          }),
+          createSurface({
+            id: RECOVER_CODE_DIALOG,
+            role: "dialog",
+            filter: (data) => data.component === RECOVER_CODE_DIALOG,
+            component: ({ data }) => /* @__PURE__ */ React4.createElement(RecoveryCodeDialog, data.subject)
+          })
+        ]
       },
       graph: {
         builder: (plugins) => {
-          const intentPlugin = resolvePlugin(plugins, parseIntentPlugin);
+          const dispatch = resolvePlugin(plugins, parseIntentPlugin)?.provides.intent.dispatchPromise;
           const id = `${CLIENT_PLUGIN}/open-shell`;
           return createExtension({
             id: CLIENT_PLUGIN,
@@ -264,12 +262,7 @@ var ClientPlugin = ({ appKey, invitationUrl = window.location.origin, invitation
               {
                 id,
                 data: async () => {
-                  await intentPlugin?.provides.intent.dispatch([
-                    {
-                      plugin: CLIENT_PLUGIN,
-                      action: ClientAction.SHARE_IDENTITY
-                    }
-                  ]);
+                  await dispatch?.(createIntent3(ClientAction.ShareIdentity));
                 },
                 properties: {
                   label: [
@@ -293,149 +286,108 @@ var ClientPlugin = ({ appKey, invitationUrl = window.location.origin, invitation
         }
       },
       intent: {
-        resolver: async (intent) => {
-          switch (intent.action) {
-            case ClientAction.CREATE_IDENTITY: {
-              const data = await client.halo.createIdentity();
-              return {
-                data,
-                intents: [
-                  [
-                    {
-                      action: OBSERVABILITY_ACTION,
-                      data: {
-                        name: "identity.create"
-                      }
-                    }
-                  ]
-                ]
-              };
-            }
-            case ClientAction.JOIN_IDENTITY: {
-              return {
-                data: true,
-                intents: [
-                  [
-                    {
-                      action: LayoutAction3.SET_LAYOUT,
-                      data: {
-                        element: "dialog",
-                        component: "dxos.org/plugin/client/JoinDialog",
-                        dialogBlockAlign: "start",
-                        subject: {
-                          initialInvitationCode: intent.data?.invitationCode,
-                          initialDisposition: "accept-halo-invitation"
-                        }
-                      }
-                    }
-                  ]
-                ]
-              };
-            }
-            case ClientAction.SHARE_IDENTITY: {
-              return {
-                data: true,
-                intents: [
-                  [
-                    {
-                      action: LayoutAction3.SET_LAYOUT,
-                      data: {
-                        element: "dialog",
-                        component: "dxos.org/plugin/client/IdentityDialog",
-                        dialogBlockAlign: "start"
-                      }
-                    }
-                  ],
-                  [
-                    {
-                      action: OBSERVABILITY_ACTION,
-                      data: {
-                        name: "identity.share"
-                      }
-                    }
-                  ]
-                ]
-              };
-            }
-            case ClientAction.RECOVER_IDENTITY: {
-              return {
-                data: true,
-                intents: [
-                  [
-                    {
-                      action: LayoutAction3.SET_LAYOUT,
-                      data: {
-                        element: "dialog",
-                        component: "dxos.org/plugin/client/JoinDialog",
-                        dialogBlockAlign: "start",
-                        subject: {
-                          initialDisposition: "recover-identity"
-                        }
-                      }
-                    }
-                  ]
-                ]
-              };
-            }
-            case ClientAction.RESET_STORAGE: {
-              await onReset?.({
-                target: intent.data?.target
-              });
-              return {
-                data: true
-              };
-            }
-            case ClientAction.CREATE_AGENT: {
-              invariant(client.services.services.EdgeAgentService, "Missing EdgeAgentService", {
-                F: __dxlog_file,
-                L: 283,
-                S: void 0,
-                A: [
-                  "client.services.services.EdgeAgentService",
-                  "'Missing EdgeAgentService'"
-                ]
-              });
-              await client.services.services.EdgeAgentService.createAgent(null, {
-                timeout: 1e4
-              });
-              return {
-                data: true
-              };
-            }
-            case ClientAction.CREATE_RECOVERY_CODE: {
-              invariant(client.services.services.IdentityService, "IdentityService not available", {
-                F: __dxlog_file,
-                L: 289,
-                S: void 0,
-                A: [
-                  "client.services.services.IdentityService",
-                  "'IdentityService not available'"
-                ]
-              });
-              const { seedphrase } = await client.services.services.IdentityService.createRecoveryPhrase();
-              return {
-                data: true,
-                intents: [
-                  [
-                    {
-                      action: LayoutAction3.SET_LAYOUT,
-                      data: {
-                        element: "dialog",
-                        dialogBlockAlign: "start",
-                        dialogType: "alert",
-                        state: true,
-                        component: "dxos.org/plugin/client/RecoveryCodeDialog",
-                        subject: {
-                          code: seedphrase
-                        }
-                      }
-                    }
-                  ]
-                ]
-              };
-            }
-          }
-        }
+        resolvers: () => [
+          createResolver(ClientAction.CreateIdentity, async () => {
+            const data = await client.halo.createIdentity();
+            return {
+              data,
+              intents: [
+                createIntent3(ObservabilityAction2.SendEvent, {
+                  name: "identity.create"
+                })
+              ]
+            };
+          }),
+          createResolver(ClientAction.JoinIdentity, async (data) => {
+            return {
+              intents: [
+                createIntent3(LayoutAction3.SetLayout, {
+                  element: "dialog",
+                  component: JOIN_DIALOG,
+                  dialogBlockAlign: "start",
+                  subject: {
+                    initialInvitationCode: data.invitationCode,
+                    initialDisposition: "accept-halo-invitation"
+                  }
+                })
+              ]
+            };
+          }),
+          createResolver(ClientAction.ShareIdentity, async () => {
+            return {
+              intents: [
+                createIntent3(LayoutAction3.SetLayout, {
+                  element: "dialog",
+                  component: IDENTITY_DIALOG,
+                  dialogBlockAlign: "start"
+                }),
+                createIntent3(ObservabilityAction2.SendEvent, {
+                  name: "identity.share"
+                })
+              ]
+            };
+          }),
+          createResolver(ClientAction.RecoverIdentity, async () => {
+            return {
+              intents: [
+                createIntent3(LayoutAction3.SetLayout, {
+                  element: "dialog",
+                  component: JOIN_DIALOG,
+                  dialogBlockAlign: "start",
+                  subject: {
+                    initialDisposition: "recover-identity"
+                  }
+                })
+              ]
+            };
+          }),
+          createResolver(ClientAction.ResetStorage, async (data) => {
+            await onReset?.({
+              target: data.target
+            });
+            return {};
+          }),
+          createResolver(ClientAction.CreateAgent, async () => {
+            invariant(client.services.services.EdgeAgentService, "Missing EdgeAgentService", {
+              F: __dxlog_file,
+              L: 203,
+              S: void 0,
+              A: [
+                "client.services.services.EdgeAgentService",
+                "'Missing EdgeAgentService'"
+              ]
+            });
+            await client.services.services.EdgeAgentService.createAgent(null, {
+              timeout: 1e4
+            });
+          }),
+          createResolver(ClientAction.CreateRecoveryCode, async () => {
+            invariant(client.services.services.IdentityService, "IdentityService not available", {
+              F: __dxlog_file,
+              L: 207,
+              S: void 0,
+              A: [
+                "client.services.services.IdentityService",
+                "'IdentityService not available'"
+              ]
+            });
+            const { seedphrase } = await client.services.services.IdentityService.createRecoveryPhrase();
+            return {
+              intents: [
+                createIntent3(LayoutAction3.SetLayout, {
+                  element: "dialog",
+                  dialogBlockAlign: "start",
+                  dialogType: "alert",
+                  state: true,
+                  component: RECOVER_CODE_DIALOG,
+                  subject: {
+                    code: seedphrase
+                  }
+                })
+              ]
+            };
+          })
+        ]
       }
     }
   };
@@ -445,7 +397,6 @@ var ClientPlugin = ({ appKey, invitationUrl = window.location.origin, invitation
 var src_default = ClientPlugin;
 export {
   ClientPlugin,
-  src_default as default,
-  parseClientPlugin
+  src_default as default
 };
 //# sourceMappingURL=index.mjs.map