@lowdefy/shell 3.23.3 → 7.2.0

package/scripts/createShellAssets.mjs

@@ -0,0 +1,54 @@
+/*
+  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.
+*/
+
+/*
+  Writes a shell's Android adaptive-icon foreground from its 1024×1024 icon: the icon scaled into
+  the centre 66% of a transparent 1024×1024 canvas, the safe zone a launcher's mask never cuts.
+  app.config.ts runs it when the shell's icon has no foreground yet (the app config is evaluated
+  synchronously, and image code is asynchronous).
+
+    node scripts/createShellAssets.mjs <icon.png> <foreground.png>
+*/
+
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const Jimp = require('jimp-compact');
+
+const SIZE = 1024;
+const SAFE_ZONE = 0.66;
+
+async function createAdaptiveIconForeground({ icon, output }) {
+  const image = await Jimp.read(icon);
+  const inner = Math.round(SIZE * SAFE_ZONE);
+  image.contain(inner, inner);
+  const canvas = new Jimp(SIZE, SIZE, 0x00000000);
+  canvas.composite(image, Math.round((SIZE - inner) / 2), Math.round((SIZE - inner) / 2));
+  await canvas.writeAsync(output);
+  return output;
+}
+
+if (fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const [icon, output] = process.argv.slice(2);
+  if (icon === undefined || output === undefined) {
+    throw new Error('Usage: node scripts/createShellAssets.mjs <icon.png> <foreground.png>');
+  }
+  await createAdaptiveIconForeground({ icon, output });
+}
+
+export { createAdaptiveIconForeground };

package/scripts/createShellVersion.mjs

@@ -0,0 +1,83 @@
+/*
+  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.
+*/
+
+/*
+  The shell's version: the @lowdefy/shell package version, which the shell sends as
+  `x-lowdefy-shell` and compares with an app's `mobile.minShellVersion`
+  (src/version/isShellTooOld.js).
+
+  Written to src/version/shellVersion.js, which the shell's JavaScript imports
+  (src/config/getShellConfig.js). The version travels in the JavaScript bundle, not the Expo config,
+  so it is the version of the code that runs: an embedded launch reads the Expo config the native
+  build embedded, which a shell running newer JavaScript from Metro has outgrown. Only the
+  version is written, not package.json, which would put every dependency name in the bundle. The
+  file is committed; src/version/shellVersion.test.js fails when it is stale, and
+  `pnpm release:version` rewrites it after the version bump.
+
+    node scripts/createShellVersion.mjs           prints the version
+    node scripts/createShellVersion.mjs --write   writes src/version/shellVersion.js
+
+  Usage: pnpm --filter=@lowdefy/shell shell-version
+*/
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const shellRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const HEADER = `/*
+  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.
+*/
+
+// Generated by scripts/createShellVersion.mjs from package.json. Do not edit.
+`;
+
+function createShellVersion() {
+  const { version } = JSON.parse(fs.readFileSync(path.join(shellRoot, 'package.json'), 'utf8'));
+  return version;
+}
+
+function createShellVersionModule() {
+  return `${HEADER}\nconst shellVersion = ${JSON.stringify(
+    createShellVersion()
+  )};\n\nexport default shellVersion;\n`;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (process.argv.includes('--write')) {
+    fs.writeFileSync(
+      path.join(shellRoot, 'src/version/shellVersion.js'),
+      createShellVersionModule()
+    );
+  } else {
+    process.stdout.write(createShellVersion());
+  }
+}
+
+export default createShellVersion;

package/scripts/createTypeManifest.mjs

@@ -0,0 +1,205 @@
+/*
+  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.
+*/
+
+/*
+  The type manifest: every block, action and operator type this shell carries, with the plugin
+  package that provides it and that package's major version. A page renders only when the shell
+  carries every type its type set names at the same major version (src/types/checkTypeSet.js).
+
+  Made from src/plugins/shellPlugins.json, the plugin packages the shell registers
+  (src/plugins/types.js), and the shell's plugins (shell.json `plugins`, read with
+  readShellConfig.js): each one's `./types` `native.blocks` and `native.actions`, named with its
+  typePrefix, as src/plugins/appTypes.js registers them. A plugin without a `./types` export adds
+  none. Written to src/plugins/typeManifest.js, which the shell's JavaScript
+  imports (src/config/getShellConfig.js). The manifest travels in the JavaScript bundle, not the
+  Expo config, so it always matches the code that runs: a type added to the plugin maps reaches a
+  shell with an over-the-air update or from Metro, without a native build. The file is committed;
+  src/plugins/types.test.js fails when it is stale, and `pnpm release:version` rewrites it after
+  the version bump. `lowdefy mobile config` rewrites it in a copied shell, with that shell's
+  plugins.
+
+    node scripts/createTypeManifest.mjs           prints the manifest as JSON
+    node scripts/createTypeManifest.mjs --write   writes src/plugins/typeManifest.js
+
+  Usage: pnpm --filter=@lowdefy/shell type-manifest
+*/
+
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const shellRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+const readShellConfig = require('../readShellConfig.js');
+
+const NATIVE_CATEGORIES = ['actions', 'blocks'];
+
+const CATEGORIES = ['actions', 'blocks', 'operators'];
+
+const HEADER = `/*
+  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.
+*/
+
+// Generated by scripts/createTypeManifest.mjs from src/plugins/shellPlugins.json and shell.json
+// \`plugins\`. Do not edit.
+`;
+
+// The plugin packages export no package.json, so it is found above the resolved types file.
+function readMajorVersion(packageName) {
+  let directory = path.dirname(require.resolve(`${packageName}/types`));
+  while (!fs.existsSync(path.join(directory, 'package.json'))) {
+    directory = path.dirname(directory);
+  }
+  const { name, version } = JSON.parse(
+    fs.readFileSync(path.join(directory, 'package.json'), 'utf8')
+  );
+  if (name !== packageName) {
+    throw new Error(`Could not find the package.json of "${packageName}".`);
+  }
+  return Number(version.split('.')[0]);
+}
+
+function getPackageTypeNames({ category, types }) {
+  if (category === 'operators') {
+    return types.operators.client;
+  }
+  return types[category];
+}
+
+// Two packages giving one type name would leave one of them unreachable on a page.
+function addType({ category, manifest, name, packageName }) {
+  const existing = manifest[category][name];
+  if (existing !== undefined && existing.package !== packageName) {
+    throw new Error(
+      `Shell plugin "${packageName}" gives the ${category.slice(0, -1)} type "${name}", which "${
+        existing.package
+      }" already gives. Set a typePrefix on the plugin in mobile.shells[].plugins.`
+    );
+  }
+  manifest[category][name] = { package: packageName, version: readMajorVersion(packageName) };
+}
+
+// A shell plugin need not export "./types": a native-only plugin, such as a wrapped SDK, gives no
+// types. Resolving a missing export throws, so the plugin's own package.json says, found on the
+// lookup paths of `require` (its exports need not list package.json).
+function hasTypesExport(packageName) {
+  const packageJsonPath = require.resolve
+    .paths(packageName)
+    .map((directory) => path.join(directory, packageName, 'package.json'))
+    .find((filePath) => fs.existsSync(filePath));
+  if (packageJsonPath === undefined) {
+    throw new Error(`Shell plugin "${packageName}" is not installed.`);
+  }
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.exports?.['./types'] !== undefined;
+}
+
+// A shell plugin's native type names, from its `./types` `native: { blocks, actions }`.
+async function addShellPluginTypes({ manifest, plugin }) {
+  const { default: types } = await import(pathToFileURL(require.resolve(`${plugin.name}/types`)));
+  NATIVE_CATEGORIES.forEach((category) => {
+    const names = types.native?.[category] ?? [];
+    if (!Array.isArray(names)) {
+      throw new Error(
+        `Shell plugin "${
+          plugin.name
+        }" "./types" native.${category} should be an array of type names. Received ${JSON.stringify(
+          names
+        )}.`
+      );
+    }
+    names.forEach((name) => {
+      addType({
+        category,
+        manifest,
+        name: `${plugin.typePrefix ?? ''}${name}`,
+        packageName: plugin.name,
+      });
+    });
+  });
+}
+
+function readShellPlugins() {
+  return JSON.parse(fs.readFileSync(path.join(shellRoot, 'src/plugins/shellPlugins.json'), 'utf8'));
+}
+
+async function createTypeManifest({
+  plugins = readShellPlugins(),
+  shellPlugins = readShellConfig().shell.plugins ?? [],
+} = {}) {
+  const manifest = { actions: {}, blocks: {}, operators: {} };
+  for (const plugin of plugins) {
+    if (!CATEGORIES.includes(plugin.category)) {
+      throw new Error(
+        `Shell plugin "${plugin.package}" has an unknown category. Received ${JSON.stringify(
+          plugin.category
+        )}.`
+      );
+    }
+    const { default: types } = await import(`${plugin.package}/types`);
+    const packageTypeNames = getPackageTypeNames({ category: plugin.category, types });
+    const names = plugin.types ?? packageTypeNames;
+    names.forEach((name) => {
+      if (!packageTypeNames.includes(name)) {
+        throw new Error(
+          `Shell plugin "${plugin.package}" has no ${plugin.category} type "${name}".`
+        );
+      }
+      addType({ category: plugin.category, manifest, name, packageName: plugin.package });
+    });
+  }
+  for (const plugin of shellPlugins) {
+    if (hasTypesExport(plugin.name)) {
+      await addShellPluginTypes({ manifest, plugin });
+    }
+  }
+  return manifest;
+}
+
+async function createTypeManifestModule() {
+  const manifest = await createTypeManifest();
+  return `${HEADER}\nconst typeManifest = ${JSON.stringify(
+    manifest,
+    null,
+    2
+  )};\n\nexport default typeManifest;\n`;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (process.argv.includes('--write')) {
+    fs.writeFileSync(
+      path.join(shellRoot, 'src/plugins/typeManifest.js'),
+      await createTypeManifestModule()
+    );
+  } else {
+    process.stdout.write(JSON.stringify(await createTypeManifest()));
+  }
+}
+
+export default createTypeManifest;

package/shell.dev.json

@@ -0,0 +1,11 @@
+{
+  "id": "lowdefy-dev",
+  "name": "Lowdefy Dev",
+  "profile": "dev",
+  "scheme": "lowdefy-dev",
+  "environment": "dev",
+  "ios": { "bundleIdentifier": "com.lowdefy.dev" },
+  "android": { "package": "com.lowdefy.dev" },
+  "store": {},
+  "app": { "id": "dev", "name": "Lowdefy Dev", "urls": { "dev": "http://localhost:3000" } }
+}

package/shellVariant.js

@@ -0,0 +1,126 @@
+/*
+  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.
+*/
+
+const {
+  applyExtensions,
+  DEV_ENTRY,
+  EXTENSIONS,
+  PROFILES,
+  mergeProfiles,
+  pluginName,
+  resolveProfile,
+} = require('./profiles.js');
+
+const VARIANTS = ['dev', 'release'];
+
+// The string the dev-tab client sends to the dev server. scripts/checkReleaseBundle.mjs fails when a
+// release bundle holds it. Keep it in step with src/dev/tab/devClientMarker.js.
+const DEV_CLIENT_MARKER = 'lowdefy-dev-tab-client';
+
+// Everything any profile or extension carries: every module, entry and permission a build can
+// leave out.
+const EVERYTHING = applyExtensions(
+  Object.keys(PROFILES).reduce(
+    (all, name) => mergeProfiles(all, resolveProfile(name)),
+    resolveProfile('basic')
+  ),
+  Object.keys(EXTENSIONS)
+);
+
+// What the `dev` profile adds itself: the developer features, which a release build never carries.
+const DEV_ONLY = PROFILES.dev;
+
+// The shell's capability profile: shell.json `profile`, else `dev` for Lowdefy Dev and `basic` for
+// any other shell.
+function getProfileName({ shell, variant }) {
+  return shell.profile ?? (variant === 'dev' ? 'dev' : 'basic');
+}
+
+/**
+ * What a shell build of this variant carries: its profile, resolved (profiles.js), with its
+ * extensions (shell.json `extensions`). The dev variant also carries Lowdefy Dev's developer
+ * features, whatever the profile; a release build carries none of them.
+ */
+function getShellProfile({ shell, variant }) {
+  const profile = applyExtensions(
+    resolveProfile(getProfileName({ shell, variant })),
+    shell.extensions
+  );
+  if (variant === 'dev') {
+    return mergeProfiles(profile, { ...resolveProfile('dev'), name: profile.name });
+  }
+  return {
+    ...profile,
+    modules: Object.fromEntries(
+      Object.entries(profile.modules).filter(([name]) => !(name in DEV_ONLY.modules))
+    ),
+    plugins: profile.plugins.filter((plugin) => !(pluginName(plugin) in DEV_ONLY.modules)),
+    permissions: profile.permissions.filter(
+      (permission) => !DEV_ONLY.permissions.includes(permission)
+    ),
+    jsEntries: profile.jsEntries.filter((entry) => !DEV_ONLY.jsEntries.includes(entry)),
+  };
+}
+
+/**
+ * What a shell build of this variant leaves out: every module, JavaScript entry and permission some
+ * profile carries and its own does not. app.config.ts leaves the modules unlinked and their config
+ * plugins unapplied (withExcludedNativeModules.js) and blocks the permissions; metro.config.js
+ * resolves the entries to empty modules.
+ *
+ * @returns {{ modules: Object<string, string|null>, jsEntries: string[], permissions: string[] }}
+ *   modules as { [package]: nativeModuleName }.
+ */
+function getExclusions({ shell, variant }) {
+  const profile = getShellProfile({ shell, variant });
+  return {
+    modules: Object.fromEntries(
+      Object.entries(EVERYTHING.modules).filter(([name]) => !(name in profile.modules))
+    ),
+    jsEntries: EVERYTHING.jsEntries.filter((entry) => !profile.jsEntries.includes(entry)),
+    permissions: EVERYTHING.permissions.filter(
+      (permission) => !profile.permissions.includes(permission)
+    ),
+  };
+}
+
+// The native modules a shell build leaves unlinked, as { [package]: nativeModuleName }.
+function getExcludedModules({ shell, variant }) {
+  return getExclusions({ shell, variant }).modules;
+}
+
+// LOWDEFY_SHELL_VARIANT=dev | release. Without it, Lowdefy Dev (no LOWDEFY_SHELL_CONFIG) is dev and
+// every other shell is release, so a customer shell leaves the developer features out unless its
+// build asks for them.
+function getShellVariant(env = process.env) {
+  const variant = env.LOWDEFY_SHELL_VARIANT || (env.LOWDEFY_SHELL_CONFIG ? 'release' : 'dev');
+  if (!VARIANTS.includes(variant)) {
+    throw new Error(
+      `LOWDEFY_SHELL_VARIANT must be "dev" or "release". Received ${JSON.stringify(variant)}.`
+    );
+  }
+  return variant;
+}
+
+module.exports = {
+  DEV_CLIENT_MARKER,
+  DEV_ENTRY,
+  getExcludedModules,
+  getExclusions,
+  getProfileName,
+  getShellProfile,
+  getShellVariant,
+};

package/src/ShellContext.js

@@ -0,0 +1,32 @@
+/*
+  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 { createContext, useContext, useSyncExternalStore } from 'react';
+
+// { auth, session, host, locale, shell } of the app the shell has open.
+const ShellContext = createContext(null);
+
+function useShell() {
+  return useContext(ShellContext);
+}
+
+function useSessionState() {
+  const { session } = useShell();
+  return useSyncExternalStore(session.subscribe, session.getState);
+}
+
+export { useSessionState, useShell };
+export default ShellContext;

package/src/actions/CopyToClipboard.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 { type } from '@lowdefy/helpers';
+
+// The native body of actions-core's CopyToClipboard, with its params ({ copy }), through
+// expo-clipboard (globals.clipboard).
+async function CopyToClipboard({ globals, params }) {
+  const { copy } = params;
+  if (!type.isString(copy)) {
+    throw new Error(`CopyToClipboard requires "copy" text. Received ${JSON.stringify(copy)}.`);
+  }
+  await globals.clipboard.setString(copy);
+}
+
+export default CopyToClipboard;

package/src/actions/CopyToClipboard.test.js

@@ -0,0 +1,33 @@
+/*
+  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 { jest } from '@jest/globals';
+
+import CopyToClipboard from './CopyToClipboard.js';
+
+test('CopyToClipboard copies the text through the shell clipboard', async () => {
+  const clipboard = { setString: jest.fn(async () => undefined) };
+  await CopyToClipboard({ globals: { clipboard }, params: { copy: 'JOB-42' } });
+  expect(clipboard.setString.mock.calls).toEqual([['JOB-42']]);
+});
+
+test('CopyToClipboard throws when there is no text to copy', async () => {
+  const clipboard = { setString: jest.fn(async () => undefined) };
+  await expect(CopyToClipboard({ globals: { clipboard }, params: {} })).rejects.toThrow(
+    'CopyToClipboard requires "copy" text. Received undefined.'
+  );
+  expect(clipboard.setString).not.toHaveBeenCalled();
+});

package/src/actions/GeolocationCurrentPosition.js

@@ -0,0 +1,61 @@
+/*
+  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';
+import { getDeviceFeature, hasDeviceFeature } from '@lowdefy/blocks-native/device';
+
+import injected from '../device/injected.js';
+
+function numberOrNull(value) {
+  return type.isNumber(value) ? value : null;
+}
+
+/**
+ * The native body of actions-core's GeolocationCurrentPosition, answering as the web body does:
+ * `{ coords, timestamp }`, or `{ code: 1, error: 'PERMISSION_DENIED', message }` when location is
+ * refused. A location Lowdefy Dev injected (src/device/injected.js) answers first; otherwise the
+ * shell's location feature reads the phone (profile field and up), and a shell without it throws.
+ */
+async function GeolocationCurrentPosition({ params }) {
+  if (injected('permission:location') === 'denied') {
+    return { code: 1, error: 'PERMISSION_DENIED', message: 'Location permission was denied.' };
+  }
+  const location = injected('location');
+  if (type.isUndefined(location)) {
+    if (!hasDeviceFeature('location')) {
+      throw new Error(
+        'GeolocationCurrentPosition needs a shell that carries location (profile field). In Lowdefy Dev, inject a location.'
+      );
+    }
+    return getDeviceFeature({ feature: 'location', action: 'GeolocationCurrentPosition' }).current(
+      params ?? {}
+    );
+  }
+  return {
+    coords: {
+      accuracy: numberOrNull(location.accuracy),
+      altitude: numberOrNull(location.altitude),
+      altitudeAccuracy: numberOrNull(location.altitudeAccuracy),
+      heading: numberOrNull(location.heading),
+      latitude: location.latitude,
+      longitude: location.longitude,
+      speed: numberOrNull(location.speed),
+    },
+    timestamp: location.timestamp ?? Date.now(),
+  };
+}
+
+export default GeolocationCurrentPosition;