@lowdefy/shell 3.23.2 → 7.2.0

package/src/native/openPath.js

@@ -0,0 +1,55 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+// A path inside the app: one leading slash. "//evil.com/x" and "/\evil.com/x" are links to another
+// host (the router opens them as external URLs), and a control character can hide either (a URL
+// parser drops tabs and newlines). A scheme cannot start a path that starts with "/".
+function isAppPath(path) {
+  return (
+    type.isString(path) &&
+    path.startsWith('/') &&
+    !/^\/[/\\]/.test(path) &&
+    // eslint-disable-next-line no-control-regex
+    !/[\u0000-\u001f]/.test(path)
+  );
+}
+
+/**
+ * Opens one of the app's pages by path, as a notification tap, a shortcut, a widget or a share
+ * does: "/tasks/42?tab=notes", with a query object merged into the path's own. Anything that is not
+ * a path inside the app is ignored.
+ *
+ * @param {Object} params
+ * @param {Object} params.app The open app (currentApp.js).
+ * @param {string} params.path
+ * @param {Object} [params.query]
+ */
+function openPath({ app, path, query }) {
+  if (!isAppPath(path)) {
+    return;
+  }
+  const [pathname, search = ''] = path.split('?');
+  const params = new URLSearchParams(search);
+  Object.entries(query ?? {}).forEach(([key, value]) => {
+    params.set(key, type.isString(value) ? value : JSON.stringify(value));
+  });
+  const queryString = params.toString();
+  app.router.push({ pathname, query: queryString === '' ? undefined : queryString });
+}
+
+export default openPath;

package/src/native/openPath.test.js

@@ -0,0 +1,39 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import openPath from './openPath.js';
+
+function open(path, query) {
+  const app = { router: { push: jest.fn() } };
+  openPath({ app, path, query });
+  return app.router.push;
+}
+
+test('openPath opens a page of the app with its query and the query passed', () => {
+  expect(open('/tasks/42?tab=notes', { shared: { n: 1 } })).toHaveBeenCalledWith({
+    pathname: '/tasks/42',
+    query: 'tab=notes&shared=%7B%22n%22%3A1%7D',
+  });
+  expect(open('/tasks')).toHaveBeenCalledWith({ pathname: '/tasks', query: undefined });
+});
+
+test('openPath ignores anything that is not a path inside the app', () => {
+  ['//evil.com/x', '/\\evil.com/x', '/\t/evil.com', 'https://evil.com', 'tasks/1', null].forEach(
+    (path) => {
+      expect(open(path)).not.toHaveBeenCalled();
+    }
+  );
+});

package/src/native/parseShellLink.js

@@ -0,0 +1,38 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+/**
+ * A link to the shell's own scheme that the shell handles itself, not the router:
+ * - `<scheme>://shortcut/<id>`, from the App Shortcuts intent: { kind: 'shortcut', id };
+ * - `<scheme>://expo-sharing`, from the share extension: { kind: 'share' }.
+ * null for any other link.
+ *
+ * @param {string} url
+ */
+function parseShellLink(url) {
+  const match = /^[a-z][a-z0-9+.-]*:\/\/(shortcut\/([^/?#]+)|expo-sharing)(?:[/?#]|$)/.exec(
+    url ?? ''
+  );
+  if (match === null) {
+    return null;
+  }
+  if (match[2] !== undefined) {
+    return { kind: 'shortcut', id: decodeURIComponent(match[2]) };
+  }
+  return { kind: 'share' };
+}
+
+export default parseShellLink;

package/src/native/parseShellLink.test.js

@@ -0,0 +1,29 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import parseShellLink from './parseShellLink.js';
+
+test('parseShellLink reads a shortcut link and the share extension link', () => {
+  expect(parseShellLink('acme://shortcut/new-job')).toEqual({ kind: 'shortcut', id: 'new-job' });
+  expect(parseShellLink('acme://expo-sharing')).toEqual({ kind: 'share' });
+  expect(parseShellLink('acme://expo-sharing?x=1')).toEqual({ kind: 'share' });
+});
+
+test('parseShellLink leaves page links and other apps to the router', () => {
+  expect(parseShellLink('acme://tasks/42')).toBe(null);
+  expect(parseShellLink('https://field.example.com/tasks/42')).toBe(null);
+  expect(parseShellLink(null)).toBe(null);
+});

package/src/native/startAppServices.js

@@ -0,0 +1,94 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { AppState } from 'react-native';
+import { getDeviceFeature, hasDeviceFeature } from '@lowdefy/blocks-native/device';
+
+import refreshWidgets from '../widgets/refreshWidgets.js';
+import { setCurrentApp } from './currentApp.js';
+import startBackgroundFetch from './backgroundFetch.js';
+import startNotifications from '../notifications/startNotifications.js';
+import startShareIn from './startShareIn.js';
+import startShortcuts from './startShortcuts.js';
+import whenAppReady from './whenAppReady.js';
+
+/**
+ * Starts the native work of the open app once its auth and session exist: notifications, quick
+ * actions and App Shortcuts, share-in and background fetch listen at once, and their launch work
+ * waits on `app.ready` (whenAppReady: the token read and a root held). Once ready, the app becomes
+ * the current app (currentApp.js) for work started outside React, the offline request queue starts
+ * and the widgets refresh. When the app goes to the background, a scan screen's brightness goes
+ * back to the system.
+ *
+ * @param {Object} params
+ * @param {Object} params.app { apiBase, auth, host, requestQueue, session, shell, triggerAppEvent }.
+ * @returns {{ app: Object, shareIn: Object, stop: () => void }}
+ */
+function startAppServices({ app: opened }) {
+  const ready = whenAppReady({ auth: opened.auth, session: opened.session });
+  const app = {
+    apiBase: opened.apiBase,
+    auth: opened.auth,
+    fetch: opened.auth.fetch,
+    ready: ready.promise,
+    requestQueue: opened.requestQueue,
+    router: opened.host.router,
+    session: opened.session,
+    shell: opened.shell,
+    tokenStore: opened.auth.tokenStore,
+    triggerAppEvent: opened.triggerAppEvent,
+  };
+  const shareIn = startShareIn({ app });
+  // Lowdefy Dev's share injection hands payloads to it (src/dev/inject/injectShare.js).
+  app.receiveShare = shareIn.receive;
+  let stopped = false;
+  const stops = [
+    ready.stop,
+    startNotifications({ app }),
+    startShortcuts({ app }),
+    startBackgroundFetch({ app }),
+    shareIn.stop,
+  ];
+  ready.promise.then(() => {
+    if (stopped) return;
+    setCurrentApp(app);
+    stops.push(app.requestQueue.start());
+    refreshWidgets().catch(() => {});
+  });
+  const appState = AppState.addEventListener('change', (state) => {
+    if (state === 'active') {
+      refreshWidgets().catch(() => {});
+      return;
+    }
+    if (state === 'background' && hasDeviceFeature('brightness')) {
+      getDeviceFeature({ feature: 'brightness', action: 'background' })
+        .set({ reset: true })
+        .catch(() => {});
+    }
+  });
+  stops.push(() => appState.remove());
+  return {
+    app,
+    shareIn,
+    stop: () => {
+      stopped = true;
+      setCurrentApp(null);
+      stops.forEach((stop) => stop());
+    },
+  };
+}
+
+export default startAppServices;

package/src/native/startAppServices.test.js

@@ -0,0 +1,97 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { peekCurrentApp } from './currentApp.js';
+import startAppServices from './startAppServices.js';
+import whenAppReady from './whenAppReady.js';
+
+function createStore(initial) {
+  let state = initial;
+  const listeners = new Set();
+  return {
+    getState: () => state,
+    set(update) {
+      state = { ...state, ...update };
+      listeners.forEach((listener) => listener());
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}
+
+function createOpened() {
+  const auth = createStore({ status: 'starting' });
+  auth.fetch = jest.fn();
+  auth.tokenStore = { get: () => null, subscribe: () => () => undefined };
+  const session = createStore({ root: null });
+  return {
+    apiBase: 'https://app.test',
+    auth,
+    host: { router: {} },
+    requestQueue: { start: jest.fn(() => () => undefined) },
+    session,
+    triggerAppEvent: jest.fn(),
+  };
+}
+
+test('an app is ready once its auth is open and its session holds a root', async () => {
+  const { auth, session } = createOpened();
+  const ready = whenAppReady({ auth, session });
+  const settled = jest.fn();
+  ready.promise.then(settled);
+  auth.set({ status: 'locked' });
+  session.set({ root: {} });
+  await Promise.resolve();
+  expect(settled).not.toHaveBeenCalled();
+  auth.set({ status: 'open' });
+  await ready.promise;
+  expect(settled).toHaveBeenCalled();
+});
+
+test('an app that is already open and holds a root is ready at once', async () => {
+  const { auth, session } = createOpened();
+  auth.set({ status: 'open' });
+  session.set({ root: {} });
+  await expect(whenAppReady({ auth, session }).promise).resolves.toBeUndefined();
+});
+
+test('the current app and the request queue wait until the app is ready', async () => {
+  const opened = createOpened();
+  const services = startAppServices({ app: opened });
+  await Promise.resolve();
+  expect(peekCurrentApp()).toBeNull();
+  expect(opened.requestQueue.start).not.toHaveBeenCalled();
+  opened.auth.set({ status: 'open' });
+  opened.session.set({ root: {} });
+  await services.app.ready;
+  expect(peekCurrentApp()).toBe(services.app);
+  expect(opened.requestQueue.start).toHaveBeenCalledTimes(1);
+  services.stop();
+  expect(peekCurrentApp()).toBeNull();
+});
+
+test('services stopped before the app is ready never make it current', async () => {
+  const opened = createOpened();
+  const services = startAppServices({ app: opened });
+  services.stop();
+  opened.auth.set({ status: 'open' });
+  opened.session.set({ root: {} });
+  await Promise.resolve();
+  expect(peekCurrentApp()).toBeNull();
+  expect(opened.requestQueue.start).not.toHaveBeenCalled();
+});

package/src/native/startShareIn.js

@@ -0,0 +1,59 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { Linking } from 'react-native';
+import * as Sharing from 'expo-sharing';
+
+import getPagePath from './getPagePath.js';
+import openPath from './openPath.js';
+import parseShellLink from './parseShellLink.js';
+import toSharePayload from './toSharePayload.js';
+
+/**
+ * Items shared into the app (the share extension opens `<scheme>://expo-sharing`): opens
+ * mobile.share.pageId with the payload in its query as `shared`, and fires onShare with it. A shell
+ * without the share extension never gets the link.
+ *
+ * @param {Object} params
+ * @param {Object} params.app The open app (currentApp.js).
+ * @returns {{ receive: () => Promise<void>, stop: () => void }} receive takes what is waiting now,
+ *   or the payloads Lowdefy Dev's share injection passes; stop stops listening.
+ */
+function startShareIn({ app }) {
+  async function receive({ payloads: injected } = {}) {
+    const payloads = injected ?? (await Sharing.getResolvedSharedPayloadsAsync());
+    if (injected === undefined) Sharing.clearSharedPayloads();
+    if (payloads.length === 0) return;
+    // The share page's path comes from the root.
+    await app.ready;
+    const shared = toSharePayload(payloads);
+    const { root } = app.session.getState();
+    if (root?.share !== null && root?.share !== undefined) {
+      openPath({ app, path: getPagePath({ pageId: root.share.pageId, root }), query: { shared } });
+    }
+    app.triggerAppEvent({ name: 'onShare', event: shared });
+  }
+  function onUrl(url) {
+    if (parseShellLink(url)?.kind === 'share') receive().catch(() => {});
+  }
+  const urls = Linking.addEventListener('url', ({ url }) => onUrl(url));
+  Linking.getInitialURL()
+    .then(onUrl)
+    .catch(() => {});
+  return { receive, stop: () => urls.remove() };
+}
+
+export default startShareIn;

package/src/native/startShortcuts.js

@@ -0,0 +1,88 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { Linking } from 'react-native';
+import * as QuickActions from 'expo-quick-actions';
+
+import openPath from './openPath.js';
+import parseShellLink from './parseShellLink.js';
+
+// The quick action or shortcut link that launched the app runs once per launch. The services start
+// again after every sign-out, and QuickActions.initial and the initial url stay as they were, so
+// the next person to sign in would be sent to the shortcut's page again.
+let launchHandled = false;
+
+/**
+ * The app icon's quick actions and App Shortcuts, from mobile.shortcuts: set on the phone whenever
+ * the root changes (expo-quick-actions, which the App Shortcuts intent reads too). Choosing one,
+ * from the icon or from Siri or Spotlight (`<scheme>://shortcut/<id>`), opens its path and fires
+ * onShortcut with { id, title }.
+ *
+ * @param {Object} params
+ * @param {Object} params.app The open app (currentApp.js).
+ * @returns {() => void} Stops listening.
+ */
+function startShortcuts({ app }) {
+  let applied = null;
+  function applyRoot() {
+    const shortcuts = app.session.getState().root?.shortcuts;
+    if (shortcuts === undefined || shortcuts === applied) return;
+    applied = shortcuts;
+    QuickActions.setItems(
+      shortcuts.map((shortcut) => ({
+        id: shortcut.id,
+        title: shortcut.title,
+        subtitle: shortcut.subtitle,
+        icon: shortcut.icon === null ? null : `symbol:${shortcut.icon}`,
+      }))
+    ).catch(() => {});
+  }
+  // A quick action that launched the app waits for the root that names its path.
+  async function run(id) {
+    await app.ready;
+    const shortcut = (app.session.getState().root?.shortcuts ?? []).find((item) => item.id === id);
+    if (shortcut === undefined) return;
+    openPath({ app, path: shortcut.path });
+    app.triggerAppEvent({ name: 'onShortcut', event: { id: shortcut.id, title: shortcut.title } });
+  }
+  function onUrl(url) {
+    const link = parseShellLink(url);
+    if (link?.kind === 'shortcut') run(link.id).catch(() => {});
+  }
+
+  const unsubscribe = app.session.subscribe(applyRoot);
+  applyRoot();
+  const quickAction = QuickActions.addListener((action) => {
+    run(action.id).catch(() => {});
+  });
+  const urls = Linking.addEventListener('url', ({ url }) => onUrl(url));
+  if (!launchHandled) {
+    launchHandled = true;
+    if (QuickActions.initial !== undefined) {
+      run(QuickActions.initial.id).catch(() => {});
+    }
+    Linking.getInitialURL()
+      .then(onUrl)
+      .catch(() => {});
+  }
+  return () => {
+    unsubscribe();
+    quickAction.remove();
+    urls.remove();
+  };
+}
+
+export default startShortcuts;

package/src/native/startShortcuts.test.js

@@ -0,0 +1,59 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { Linking } from 'react-native';
+
+import openPath from './openPath.js';
+import startShortcuts from './startShortcuts.js';
+
+jest.mock('./openPath.js', () => jest.fn());
+// The app was launched from the New job quick action.
+jest.mock('expo-quick-actions', () => ({
+  initial: { id: 'new_job' },
+  setItems: async () => undefined,
+  addListener: () => ({ remove: () => undefined }),
+}));
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+function createApp() {
+  const root = { shortcuts: [{ id: 'new_job', title: 'New job', path: '/jobs/new', icon: null }] };
+  return {
+    ready: Promise.resolve(),
+    session: { getState: () => ({ root }), subscribe: () => () => undefined },
+    triggerAppEvent: jest.fn(),
+  };
+}
+
+test('the quick action that launched the app runs once, not again after a sign-out', async () => {
+  jest.spyOn(Linking, 'getInitialURL').mockResolvedValue(null);
+  const first = createApp();
+  const stop = startShortcuts({ app: first });
+  await flush();
+  expect(openPath).toHaveBeenCalledWith({ app: first, path: '/jobs/new' });
+  expect(first.triggerAppEvent).toHaveBeenCalledWith({
+    name: 'onShortcut',
+    event: { id: 'new_job', title: 'New job' },
+  });
+  stop();
+
+  const second = createApp();
+  startShortcuts({ app: second });
+  await flush();
+  expect(openPath).toHaveBeenCalledTimes(1);
+  expect(second.triggerAppEvent).not.toHaveBeenCalled();
+  expect(Linking.getInitialURL).toHaveBeenCalledTimes(1);
+});

package/src/native/toSharePayload.js

@@ -0,0 +1,47 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+/**
+ * What was shared into the app, from expo-sharing's resolved payloads: { text, urls, files }, files
+ * as [{ name, mimeType, size, uri, type }] (type: image, video, audio or file).
+ *
+ * @param {Object[]} payloads expo-sharing ResolvedSharePayloads.
+ */
+function toSharePayload(payloads) {
+  const texts = [];
+  const urls = [];
+  const files = [];
+  payloads.forEach((payload) => {
+    if (payload.shareType === 'text') {
+      texts.push(payload.value);
+      return;
+    }
+    if (payload.shareType === 'url' || payload.contentType === 'website') {
+      urls.push(payload.value);
+      return;
+    }
+    files.push({
+      name: payload.originalName ?? payload.value.split('/').pop(),
+      mimeType: payload.contentMimeType ?? payload.mimeType ?? null,
+      size: payload.contentSize ?? null,
+      uri: payload.contentUri ?? payload.value,
+      type: payload.contentType ?? payload.shareType,
+    });
+  });
+  return { text: texts.length === 0 ? null : texts.join('\n'), urls, files };
+}
+
+export default toSharePayload;

package/src/native/toSharePayload.test.js

@@ -0,0 +1,47 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import toSharePayload from './toSharePayload.js';
+
+test('toSharePayload splits shared text, links and files', () => {
+  expect(
+    toSharePayload([
+      { shareType: 'text', value: 'Pump 4 is leaking' },
+      { shareType: 'url', value: 'https://example.com/report' },
+      {
+        shareType: 'image',
+        value: 'file:///group/photo.jpg',
+        contentUri: 'file:///group/photo.jpg',
+        contentType: 'image',
+        contentMimeType: 'image/jpeg',
+        originalName: 'photo.jpg',
+        contentSize: 2048,
+      },
+    ])
+  ).toEqual({
+    text: 'Pump 4 is leaking',
+    urls: ['https://example.com/report'],
+    files: [
+      {
+        name: 'photo.jpg',
+        mimeType: 'image/jpeg',
+        size: 2048,
+        uri: 'file:///group/photo.jpg',
+        type: 'image',
+      },
+    ],
+  });
+});