@yahoo/uds 0.1.11 → 0.1.13

package/cli/README.md

@@ -0,0 +1,135 @@
+# UDS ClI
+
+We leverage Bluebun, which is a CLI framework inspired by [Gluegun](https://github.com/infinitered/gluegun), but specifically designed to be used with [Bun](https://bun.sh), the new JS runtime.
+
+Bluebun relies on Bun APIs and is designed to be extremely fast, with no-dependencies.
+
+# Standalone executable
+
+We use Bun to build our standalone executable. See [Bun build docs](https://bun.sh/docs/bundler/executables) for more details. The uds package.json's `build:cli` script handles building the CLI. The bin is output to the `dist/uds` binary file and this path is defined in the package.json's bin field.
+
+# Commands
+
+## Command structure
+
+Commands are organized in a tree structure. The root command is the name of the CLI (uds), and then we can have subcommands under that, and subcommands under those, and so on.
+
+For example, a command structure might look like this:
+
+```
+cli/
+  commands/
+    pizza.ts        # pizza
+    help.ts         # pizza help
+    bake/
+      bake.ts       # pizza bake
+      cheese.ts     # pizza bake cheese
+      pepperoni.ts  # pizza bake pepperoni
+```
+
+## Command files
+
+Commands are exported as defaults from each command file. They look like this:
+
+```typescript
+import { type Props } from 'bluebun';
+
+export default {
+  name: 'bake',
+  description: 'Bake a pizza',
+  alias: ['b'],
+  run: async (props: Props) => {
+    // bake it!
+  },
+};
+```
+
+## Command properties
+
+Commands have the following properties:
+
+- `name` - the name of the command
+- `description` - a description of the command for the automatic help system
+- `alias` - an array of aliases for the command (can also be a single string)
+- `run` - the function that is run when the command is run, usually `async`
+
+## Props
+
+The `run` function is passed a `Props` object. This object contains the command path, the arguments, and the options, as well as a few other useful things.
+
+Here are the properties available on the `props` object if we were to run `uds bake cheese convection --sliced --temp=400 --time 30`:
+
+- `name` - the name of the CLI (uds)
+- `cliPath` - the path to the CLI (./uds-cli)
+- `argv` - the raw arguments passed to the CLI (e.g. `["/bin/bun", "/bin/uds", "bake", "cheese", "convection", "--sliced", "--temp=400", "--time", "30"]`)
+- `commandPath` - the path to the command that was run (e.g. `["bake", "cheese"]`)
+- `arguments` - the positional arguments passed to the command (e.g. `["convection"]`)
+- `options` - the options passed to the command (e.g. `{ sliced: true, temp: 400, time: 30 }`)
+- `first` - the first argument passed to the command (e.g. `"convection"`)
+- `second` - the second argument passed to the command (e.g. `undefined`)
+- `third` - the third argument passed to the command (e.g. `undefined`)
+
+Given these props, we might have a command that looks like this:
+
+```typescript
+import { type Props, spinStart, spinStop } from 'bluebun';
+import { createPizza, slice } from './_pizza';
+import { convectionBake, toasterBake, regularBake } from './_bakePizza';
+
+export default {
+  name: 'bake',
+  description: 'Bake a pizza',
+  alias: ['b'],
+  run: async (props: Props) => {
+    const { first, second, third, options } = props;
+
+    const pizza = createPizza();
+
+    spinStart('Baking pizza...');
+    if (first === 'convection') {
+      await convectionBake(pizza, options.temp, options.time);
+    } else if (first === 'toaster') {
+      await toasterBake(pizza, options.temp, options.time);
+    } else {
+      await regularBake(pizza, options.temp, options.time);
+    }
+    spinStop('✅ Pizza baked!');
+
+    spinStart('Slicing pizza...');
+    if (options.sliced) {
+      await slice(pizza);
+    }
+    spinStop('✅ Pizza sliced!');
+  },
+};
+```
+
+# Reference
+
+Bluebun comes with a number of built-in utilities that are useful. They're all exported from `bluebun` directly, so you can import them like this:
+
+```typescript
+import { inputKey } from 'bluebun';
+```
+
+Each of the following docs has usage examples and a Testing section that gives examples on how to write tests for them.
+
+## CLI
+
+- [run](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/run.md) - run the CLI and command
+- [cli](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/cli.md) - start the CLI without running the command
+- [commandHelp](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/commandHelp.md) - get a list of all commands and their descriptions
+
+## User Interaction
+
+- [ask](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/ask.md) - ask the user a question via a prompt
+- [cursor](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/cursor.md) - manipulate the cursor
+- [inputKey](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/inputKey.md) - wait for a single keypress
+- [inputKeys](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/inputKeys.md) - wait for and handle multiple keypresses
+
+## Output
+
+- [print](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/print.md) - print a string to the terminal
+- [spinner](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/spinner.md) - start and stop a spinner
+- [progress](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/progress.md) - start, update, and stop a progress bar
+- [styles and colors](https://github.com/jamonholmgren/bluebun/blob/main/docs/reference/styles.md) - style and colorize text

package/cli/commands/config/config.ts

@@ -0,0 +1,10 @@
+import { type Props } from 'bluebun';
+import { getCommandHelp } from '../../utils/getCommandHelp';
+
+export default {
+  name: 'config',
+  description: '',
+  run: async (props: Props) => {
+    await getCommandHelp(props);
+  },
+};

package/cli/commands/config/sync.ts

@@ -0,0 +1,22 @@
+import { Props } from 'bluebun';
+import { setupConfigWorker } from '../../utils/setupConfigWorker';
+import { SyncOptions } from '../../utils/types';
+
+interface SyncProps extends Props {
+  options: SyncOptions;
+}
+
+export default {
+  name: 'sync',
+  description: '🌈 Sync',
+  run: async ({ options }: SyncProps) => {
+    await setupConfigWorker({
+      ...options,
+      onUpdate: ({ worker }) => {
+        if (!options.watch) {
+          worker.terminate();
+        }
+      },
+    });
+  },
+};

package/cli/commands/expo/_setup.ts

@@ -0,0 +1,260 @@
+import { EasJsonAccessor, EasJsonUtils, Platform } from '@expo/eas-json';
+import { type Props, print } from 'bluebun';
+import { $ } from 'bun';
+
+export interface MobileProps extends Props {
+  options: {
+    profile: string;
+    platform: Platform.IOS | Platform.ANDROID;
+    jsEngine?: 'hermes' | 'jsc';
+    debug?: boolean;
+  };
+}
+
+async function needsBinary(lib: string) {
+  const whichLib = await $`which ${lib}`.text();
+  return whichLib.includes('not found');
+}
+
+async function needsBrewFormula(formula: string) {
+  return (await $`brew list --formula | grep ${formula} | wc -l`.text()).trim() === '0';
+}
+
+export async function setup({
+  props,
+  env: envOpts,
+}: {
+  props: MobileProps;
+  env?: Partial<typeof Bun.env>;
+}) {
+  const { profile, platform, jsEngine = 'hermes', debug = false } = props.options;
+
+  /* -------------------------------------------------------------------------- */
+  /*                               HOMEBREW SETUP                               */
+  /* -------------------------------------------------------------------------- */
+  const needsBrew = await needsBinary('brew');
+  if (needsBrew) {
+    console.log('Installing brew...');
+    await $`/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`;
+    console.log('Installing brew...Complete');
+
+    /**
+     * This portion of logic was ported from the homebrew installer script
+     * https://github.com/Homebrew/install/blob/master/install.sh#L153C5-L153C63.
+     * However, their script just alerts users to the fact that they need to add
+     * brew to their path, but doesn't do it for them. This logic attempts to do that
+     * so we can automatically proceed to the next steps of auto-installing
+     * the necessary dependencies for local development.
+     */
+    const machineArch = await $`uname -m`.text();
+    const isLinux = (await $`uname`.text()) === 'Linux';
+    const shellType = await $`echo $SHELL`.text();
+    const homebrewPrefix = machineArch.includes('arm64') ? '/opt/homebrew' : '/usr/local';
+    let shellRcFile;
+
+    if (isLinux) {
+      shellRcFile = shellType.includes('zsh') ? '.zshrc' : '.bashrc';
+    } else {
+      shellRcFile = shellType.includes('zsh') ? '.zprofile' : '.bash_profile';
+    }
+
+    const shellRcPath = `${Bun.env.HOME}/${shellRcFile}`;
+    let shellRcContents = '';
+    try {
+      shellRcContents = await Bun.file(shellRcPath).text();
+    } catch (err) {
+      // Ignore if it doesn't exist. We create it below.
+    }
+
+    if (!shellRcContents.includes('homebrew')) {
+      console.log('Adding brew to $PATH...');
+      const newShellRcContents = `${shellRcContents}\neval "$(${homebrewPrefix}/bin/brew shellenv)"`;
+      await Bun.write(shellRcPath, newShellRcContents);
+    }
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                               FASTLANE SETUP                               */
+  /* -------------------------------------------------------------------------- */
+  const needsFastlane = await needsBrewFormula('fastlane');
+  if (needsFastlane) {
+    console.log('Installing fastlane...');
+    await $`brew install fastlane`;
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                               COCOAPODS SETUP                              */
+  /* -------------------------------------------------------------------------- */
+  const needsCocoapods = await needsBrewFormula('cocoapods');
+  if (needsCocoapods) {
+    console.log('Installing cocoapods...');
+    await $`brew install cocoapods`;
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                            JAVA DEVELOPMENT KIT                            */
+  /* -------------------------------------------------------------------------- */
+  if (platform === 'android') {
+    const jdkPath = await $`brew info --cask zulu17`.text();
+    const needsJdk = jdkPath.includes('unavailable');
+    if (needsJdk) {
+      console.log('Installing Java Development Kit for Android...');
+      await $`brew install --cask zulu17`;
+    }
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                                 EXPO SETUP                                 */
+  /* -------------------------------------------------------------------------- */
+  const appDirectory = Bun.env.PWD;
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(appDirectory);
+
+  const easProfiles = await EasJsonUtils.getBuildProfileNamesAsync(easJsonAccessor);
+
+  if (!easProfiles.includes(profile)) {
+    const profileNames = easProfiles.join(', ');
+    const suggestion = `Please add one or use ${profileNames}.`;
+
+    if (!profile) {
+      print(`No profile name was provided. ${suggestion}`);
+    } else {
+      print(
+        `A profile with name ${profile} does not exist as a key in eas.json > build object.\n${suggestion}`,
+      );
+    }
+    process.exit(0);
+  }
+
+  const easJsonConfig = await EasJsonUtils.getBuildProfileAsync(easJsonAccessor, platform, profile);
+
+  const easCliConfig = await EasJsonUtils.getCliConfigAsync(easJsonAccessor);
+  const easCliVersion = easCliConfig?.version ?? 'latest';
+
+  /* -------------------------------------------------------------------------- */
+  /*                                EAS CLI SETUP                               */
+  /* -------------------------------------------------------------------------- */
+  const needsEasCli = await needsBinary('eas');
+  if (needsEasCli) {
+    await $`bun install eas-cli@${easCliVersion} -g`;
+  } else {
+    const currentEasCliVersion = await $`eas --version`.text();
+    if (currentEasCliVersion !== easCliVersion) {
+      await $`bun install eas-cli@${easCliVersion} -g`;
+    }
+  }
+
+  const {
+    APP_BUNDLE_IDENTIFIER,
+    APP_ANDROID_BUNDLE_IDENTIFIER: androidId = APP_BUNDLE_IDENTIFIER as string,
+    APP_APPLE_BUNDLE_IDENTIFIER: appleId = APP_BUNDLE_IDENTIFIER as string,
+  } = easJsonConfig.env ?? {};
+
+  // TODO: Add additional checks for ensuring this value adheres to Android formatting specs
+  if (platform === Platform.ANDROID && !androidId) {
+    throw new Error(`
+      APP_ANDROID_BUNDLE_IDENTIFIER must be defined in eas.json within the ${profile} > env config.
+      See https://docs.expo.dev/build-reference/variables/#setting-plaintext-environment-variables-in-easjson for information about env variables in eas.json
+
+      This env variable is used to populate the package key in your app.config.(js|ts) > android
+      The format of this env variable must use DNS notation unique name for your app, which is a valid  Android Application ID.
+
+      For example you could use, com.company.app, where com.company is our domain and app is our app.
+
+      We recommend having the release build use the simplest identifier such as com.company.app and your debug variants
+      adding additional context such as com.company.app_debug. When publishing, the release identifier must be unique on the Play Store.
+
+      The name may only contain lowercase and uppercase letters (a-z, A-Z), numbers (0-9) and underscores (_),
+      separated by periods (.). Each component of the name should start with a lowercase letter.
+
+      These formatting rules only applies to Android. iOS has different requirements.
+
+      See https://docs.expo.dev/versions/latest/config/app/#package for more details on formatting.
+      See https://docs.expo.dev/build-reference/variants/ for information about build variants.
+      `);
+  }
+
+  // TODO: Add additional checks for ensuring this value adheres to Uniform Type Identifier
+  if (platform === Platform.IOS && !appleId) {
+    throw new Error(`
+      APP_APPLE_BUNDLE_IDENTIFIER must be defined in eas.json within the ${profile} > env config.
+      See https://docs.expo.dev/build-reference/variables/#setting-plaintext-environment-variables-in-easjson for information about env variables in eas.json
+
+      This env variable is used to populate the package key in your app.config.(js|ts) > ios
+      The format of this env variable must use DNS notation unique name for your app, which is a valid Android Application ID.
+
+      For example you could use, com.company.app, where com.company is our domain and app is our app.
+
+      We recommend having the release build use the simplest identifier such as com.company.app and your debug variants
+      adding additional context such as com.company.app-debug. When publishing, the release identifier must be unique to the App Store.
+
+      The string format should be Uniform Type Identifier(UTI), which is alphanumeric characters (A-Z,a-z,0-9), hyphen (-), and period (.)
+
+      These formatting rules only applies to iOS. Android has different requirements.
+
+      See https://docs.expo.dev/versions/latest/config/app/#bundleidentifier for more details on formatting.
+      See https://docs.expo.dev/build-reference/variants/ for information about build variants.
+      `);
+  }
+
+  const outputName = `${platform}-${profile}-${jsEngine}`;
+  // TODO: make this configurable
+  const prebuildsDir = `${appDirectory}/prebuilds`;
+  const outputDir = `${prebuildsDir}/${outputName}`;
+  const outputFileBase = `${outputDir}/${outputName}`;
+
+  let envVars = Bun.env;
+
+  envVars = {
+    ...envVars,
+    APP_ANDROID_BUNDLE_IDENTIFIER: androidId,
+    APP_APPLE_BUNDLE_IDENTIFIER: appleId,
+    RCT_NO_LAUNCH_PACKAGER: '1',
+    EXPO_NO_TELEMETRY: '1',
+    EXPO_NO_WEB_SETUP: '1',
+  };
+
+  if (debug) {
+    envVars = {
+      ...envVars,
+      DEBUG: '*',
+      EAS_LOCAL_BUILD_SKIP_CLEANUP: '1',
+      EXPO_PROFILE: '1',
+    };
+  }
+
+  if (envOpts) {
+    envVars = { ...envVars, ...envOpts };
+  }
+
+  $.env(envVars);
+
+  const output = {
+    name: outputName,
+    dir: outputDir,
+    prebuildsDir: prebuildsDir,
+    fileBase: outputFileBase,
+    artifact: platform === 'ios' ? `${outputFileBase}.tar.gz` : `${outputFileBase}.zip`,
+    app: platform === 'ios' ? `${outputFileBase}.app` : 'todo fix android',
+    get launchFile() {
+      return platform === 'ios' ? this.artifact : this.apk.signed;
+    },
+    apk: {
+      contents: `${outputFileBase}/build`,
+      rebuilt: `${outputFileBase}/binary-rebuilt.apk`,
+      rebuiltAligned: `${outputFileBase}/binary-rebuilt-aligned.apk`,
+      signed: `${outputFileBase}/binary.apk`,
+      test: `${outputFileBase}/testBinary.apk`,
+    },
+  };
+
+  return {
+    scheme: platform === 'ios' ? appleId : androidId,
+    channel: easJsonConfig.channel,
+    debug,
+    profile,
+    platform,
+    jsEngine,
+    appDirectory,
+    output,
+  };
+}

package/cli/commands/expo/build.ts

@@ -0,0 +1,15 @@
+import { $ } from 'bun';
+import type { MobileProps } from './_setup';
+import { setup } from './_setup';
+
+export default {
+  name: 'build',
+  description: '🚀 Build',
+  run: async (props: MobileProps) => {
+    const { platform, profile, output } = await setup({
+      props,
+    });
+
+    await $`eas build --local --non-interactive --json --clear-cache --platform ${platform} --profile ${profile} --output ${output.artifact}`;
+  },
+};

package/cli/commands/expo/dev.ts

@@ -0,0 +1,79 @@
+import { Props } from 'bluebun';
+import { $ } from 'bun';
+import { setup, type MobileProps } from './_setup';
+
+interface MobileStartProps extends Props {
+  options: MobileProps['options'] & {
+    // Clear the cache when starting dev server
+    clear?: boolean;
+  };
+}
+
+type SimDevice = { udid: string; name: string; state: 'Booted' | 'Shutdown' };
+type SimList = {
+  devices: {
+    ['com.apple.CoreSimulator.SimRuntime.iOS-17-2']: SimDevice[];
+  };
+};
+
+export default {
+  name: 'dev',
+  description: '🚧 Dev',
+  run: async (props: MobileStartProps) => {
+    console.log('running dev');
+    const { platform, scheme, output } = await setup({
+      props,
+      env: {
+        EXPO_USE_METRO_WORKSPACE_ROOT: '1',
+      },
+    });
+
+    if (platform === 'ios') {
+      const xcodePath = await $`xcode-select -p`.text();
+      const xcodeExists = xcodePath.startsWith('/Applications');
+
+      if (xcodeExists) {
+        await $`open -a simulator`;
+        const deviceList = (await $`xcrun simctl list devices available -j -e`.json()) as SimList;
+
+        const devices = Object.values(deviceList?.devices).flatMap((item) => item);
+
+        if (devices.length === 0) {
+          throw new Error('No devices found');
+        } else {
+          const isBooted = devices.find((device: SimDevice) => device.state === 'Booted');
+          if (!isBooted) {
+            const iphone15Max = devices.find(
+              (device: SimDevice) => device.name === 'iPhone 15 Pro Max',
+            );
+            if (!iphone15Max) {
+              throw new Error('iPhone 15 Pro Max not found');
+            } else {
+              const udid = iphone15Max.udid;
+              await $`xcrun simctl boot ${udid}`;
+            }
+          }
+        }
+      } else {
+        console.log(
+          'You must have XCode installed before continuing... Visit https://apps.apple.com/us/app/xcode/id497799835?mt=12 to download.',
+        );
+        throw new Error('XCode not installed');
+      }
+    }
+
+    await $`eas build:run --platform ${platform} --path ${output.launchFile}`;
+
+    const extraArgs = [];
+
+    if (props.options.clear) {
+      extraArgs.push('--clear');
+    }
+
+    const extrArgsString = extraArgs.join(' ');
+
+    console.log(`Starting metro server...`);
+
+    await $`expo start --${platform} --dev-client --localhost --scheme ${scheme} ${extrArgsString}`;
+  },
+};

package/cli/commands/expo/expo.ts

@@ -0,0 +1,23 @@
+import { type Props } from 'bluebun';
+import { getCommandHelp } from '../../utils/getCommandHelp';
+
+export default {
+  name: 'expo',
+  description: '',
+  run: async (props: Props) => {
+    switch (props?.first) {
+      case 'build':
+        return require('./build').default.run(props);
+      case 'dev':
+        return require('./dev').default.run(props);
+      case 'launch':
+        return require('./launch').default.run(props);
+      case 'update':
+        return require('./update').default.run(props);
+      default: {
+        await getCommandHelp(props);
+        break;
+      }
+    }
+  },
+};

package/cli/commands/expo/launch.ts

@@ -0,0 +1,15 @@
+import { $ } from 'bun';
+import type { MobileProps } from './_setup';
+import { setup } from './_setup';
+
+export default {
+  name: 'launch',
+  description: '🚀 Launch',
+  run: async (props: MobileProps) => {
+    const { platform, output } = await setup({
+      props,
+    });
+
+    await $`eas build:run --platform ${platform} --path ${output.launchFile}`;
+  },
+};

package/cli/commands/expo/update.ts

@@ -0,0 +1,16 @@
+import { $ } from 'bun';
+import type { MobileProps } from './_setup';
+import { setup } from './_setup';
+
+export default {
+  name: 'update',
+  description: '🚀 Update',
+  run: async (props: MobileProps) => {
+    const { channel } = await setup({
+      props,
+    });
+
+    await $`eas update --auto --channel ${channel}`;
+    await $`rm -rf dist`;
+  },
+};

package/cli/commands/nextjs/dev.ts

@@ -0,0 +1,17 @@
+import { setupConfigWorker } from '../../utils/setupConfigWorker';
+import { Props } from 'bluebun';
+import { SyncOptions } from '../../utils/types';
+import { $ } from 'bun';
+
+interface DevProps extends Props {
+  options: SyncOptions;
+}
+
+export default {
+  name: 'dev',
+  description: '🚧 Dev',
+  run: async ({ options }: DevProps) => {
+    await setupConfigWorker(options);
+    await $`next dev`;
+  },
+};

package/cli/commands/nextjs/nextjs.ts

@@ -0,0 +1,10 @@
+import { type Props } from 'bluebun';
+import { getCommandHelp } from '../../utils/getCommandHelp';
+
+export default {
+  name: 'nextjs',
+  description: '',
+  run: async (props: Props) => {
+    await getCommandHelp(props);
+  },
+};

package/cli/commands/uds.ts

@@ -0,0 +1,10 @@
+import { type Props } from 'bluebun';
+import { getCommandHelp } from '../utils/getCommandHelp';
+
+export default {
+  name: 'uds',
+  description: '',
+  run: async (props: Props) => {
+    await getCommandHelp(props);
+  },
+};

package/cli/commands/version.ts

@@ -0,0 +1,11 @@
+import { print } from 'bluebun';
+
+import packageJson from '../../package.json';
+
+export default {
+  name: 'version',
+  description: `💾 ${packageJson.version}`,
+  run: async () => {
+    print(packageJson.version);
+  },
+};

package/cli/env.d.ts

@@ -0,0 +1,15 @@
+declare module 'bun' {
+  interface Env {
+    PWD: string;
+    APP_APPLE_BUNDLE_IDENTIFIER: string;
+    APP_ANDROID_BUNDLE_IDENTIFIER: string;
+    RCT_NO_LAUNCH_PACKAGER?: string;
+    EXPO_NO_TELEMETRY?: string;
+    EAS_LOCAL_BUILD_ARTIFACTS_DIR?: string;
+    EAS_LOCAL_BUILD_SKIP_CLEANUP?: string;
+    EXPO_PROFILE?: string;
+    EXPO_USE_METRO_WORKSPACE_ROOT?: string;
+    EXPO_BUNDLE_APP?: string;
+    ESLINT_USE_FLAT_CONFIG?: string;
+  }
+}

package/cli/eslint.config.mjs

@@ -0,0 +1,8 @@
+import { defineFlatConfig, nodeConfig } from 'eslint-config-custom';
+
+export default defineFlatConfig(
+  nodeConfig.map((config) => ({
+    ...config,
+    files: ['**/*.{ts,tsx}'],
+  })),
+);

package/cli/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "tsconfig/bun.json",
+  "include": ["."],
+  "compilerOptions": {
+    "paths": {
+      "@yahoo/uds/*": ["../src/*"],
+      "root/*": ["../../*"],
+    },
+  },
+}