@fto-consult/expo-ui 6.37.3 → 6.37.5

package/node_modules/@react-native-async-storage/async-storage/package.json

@@ -0,0 +1,197 @@
+{
+  "name": "@react-native-async-storage/async-storage",
+  "version": "1.18.2",
+  "description": "Asynchronous, persistent, key-value storage system for React Native.",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "react-native": "src/index.ts",
+  "types": "lib/typescript/index.d.ts",
+  "files": [
+    "RNCAsyncStorage.podspec",
+    "android/build.gradle",
+    "android/src",
+    "android/testresults.gradle",
+    "ios/",
+    "jest/",
+    "lib/",
+    "macos/",
+    "src/",
+    "windows/"
+  ],
+  "author": "Krzysztof Borowy <hello@krizzu.dev>",
+  "contributors": [
+    "Evan Bacon <bacon@expo.io> (https://github.com/evanbacon)",
+    "Tommy Nguyen <4123478+tido64@users.noreply.github.com> (https://github.com/tido64)"
+  ],
+  "homepage": "https://github.com/react-native-async-storage/async-storage#readme",
+  "license": "MIT",
+  "keywords": [
+    "react-native",
+    "react native",
+    "async storage",
+    "asyncstorage",
+    "storage"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/react-native-async-storage/async-storage.git"
+  },
+  "scripts": {
+    "format": "concurrently yarn:format:*",
+    "format:c": "clang-format -i $(git ls-files '*.cpp' '*.h' '*.m' '*.mm')",
+    "format:js": "prettier --write $(git ls-files '*.js' '*.json' '*.md' '*.ts' '*.tsx' '*.yml')",
+    "prepare": "bob build",
+    "start": "react-native start",
+    "start:android": "react-native run-android",
+    "start:ios": "react-native run-ios --project-path example/ios",
+    "start:macos": "react-native run-macos --project-path example/macos --scheme AsyncStorageExample",
+    "start:web": "expo start:web",
+    "start:windows": "install-windows-test-app -p example/windows && react-native run-windows --root example --logging --no-packager --no-telemetry",
+    "build:e2e:android": "scripts/android_e2e.sh 'build'",
+    "build:e2e:ios": "scripts/ios_e2e.sh 'build'",
+    "build:e2e:macos": "scripts/macos_e2e.sh 'build'",
+    "bundle:android": "scripts/android_e2e.sh 'bundle'",
+    "bundle:ios": "scripts/ios_e2e.sh 'bundle'",
+    "bundle:macos": "react-native bundle --entry-file index.ts --platform macos --bundle-output example/index.macos.jsbundle",
+    "test": "concurrently -n lint,ts yarn:test:lint yarn:test:ts",
+    "test:lint": "eslint src/**/*.ts example/**/*.ts jest/*.js",
+    "test:ts": "tsc --project tsconfig.all.json",
+    "test:e2e:android": "detox test -c android.emu.release --maxConcurrency 1",
+    "test:e2e:ios": "detox test -c ios.sim.release --maxConcurrency 1",
+    "test:e2e:macos": "scripts/macos_e2e.sh 'test'"
+  },
+  "dependencies": {
+    "merge-options": "^3.0.4"
+  },
+  "peerDependencies": {
+    "react-native": "^0.0.0-0 || 0.60 - 0.72 || 1000.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.0",
+    "@babel/preset-env": "^7.1.6",
+    "@react-native-community/eslint-config": "^3.0.0",
+    "@semantic-release/changelog": "^6.0.0",
+    "@semantic-release/git": "^10.0.0",
+    "@types/lodash": "^4.14.184",
+    "@types/react": "^17.0.0",
+    "@types/react-native": "^0.68.0",
+    "concurrently": "^6.4.0",
+    "detox": "^19.4.5",
+    "eslint": "^8.0.0",
+    "expo": "^45.0.0",
+    "jest": "^26.6.3",
+    "jest-circus": "^26.6.1",
+    "lodash": "^4.17.21",
+    "prettier": "^2.5.1",
+    "react": "17.0.2",
+    "react-dom": "17.0.2",
+    "react-native": "^0.68.0",
+    "react-native-builder-bob": "^0.18.0",
+    "react-native-macos": "^0.68.0",
+    "react-native-test-app": "^2.3.10",
+    "react-native-web": "^0.17.0",
+    "react-native-windows": "^0.68.0",
+    "react-test-renderer": "17.0.2",
+    "semantic-release": "^19.0.0",
+    "typescript": "^4.5.0"
+  },
+  "packageManager": "yarn@3.4.1",
+  "resolutions": {
+    "body-parser/qs": "^6.7.3",
+    "find-babel-config/json5": "^2.1.1",
+    "npm/chalk": "^4.1.2"
+  },
+  "jest": {
+    "preset": "react-native",
+    "setupFiles": [
+      "./example/jest.setup.js"
+    ]
+  },
+  "detox": {
+    "test-runner": "jest",
+    "runner-config": "example/e2e/config.json",
+    "configurations": {
+      "ios.sim.release": {
+        "binaryPath": "example/ios/build/Build/Products/Release-iphonesimulator/ReactTestApp.app",
+        "type": "ios.simulator",
+        "device": {
+          "type": "iPhone 13"
+        }
+      },
+      "android.emu.release": {
+        "binaryPath": "example/android/app/build/outputs/apk/release/app-release.apk",
+        "testBinaryPath": "example/android/app/build/outputs/apk/androidTest/release/app-release-androidTest.apk",
+        "type": "android.emulator",
+        "device": {
+          "avdName": "E2E_API_30",
+          "utilBinaryPaths": [
+            "/var/tmp/test-butler.apk"
+          ]
+        }
+      },
+      "android.emu.release.next": {
+        "binaryPath": "example/android/app/build/outputs/apk/next/app-next.apk",
+        "testBinaryPath": "example/android/app/build/outputs/apk/androidTest/release/app-release-androidTest.apk",
+        "type": "android.emulator",
+        "device": {
+          "avdName": "E2E_API_30",
+          "utilBinaryPaths": [
+            "/var/tmp/test-butler.apk"
+          ]
+        }
+      }
+    }
+  },
+  "eslintConfig": {
+    "extends": [
+      "@react-native-community",
+      "plugin:jest/recommended"
+    ],
+    "rules": {
+      "dot-notation": "off"
+    }
+  },
+  "prettier": {
+    "endOfLine": "auto",
+    "singleQuote": true,
+    "overrides": [
+      {
+        "files": "*.md",
+        "options": {
+          "proseWrap": "always"
+        }
+      }
+    ]
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      "typescript"
+    ]
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "CHANGELOG.md",
+            "package.json"
+          ],
+          "message": "chore(release): ${nextRelease.version} [skip ci]"
+        }
+      ]
+    ]
+  }
+}

package/node_modules/@react-native-async-storage/async-storage/src/AsyncStorage.native.ts

@@ -0,0 +1,356 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {
+  checkValidArgs,
+  checkValidInput,
+  convertError,
+  convertErrors,
+} from './helpers';
+import RCTAsyncStorage from './RCTAsyncStorage';
+import type {
+  AsyncStorageStatic,
+  ErrorLike,
+  KeyValuePair,
+  MultiRequest,
+} from './types';
+
+if (!RCTAsyncStorage) {
+  throw new Error(`[@RNC/AsyncStorage]: NativeModule: AsyncStorage is null.
+
+To fix this issue try these steps:
+
+  • Rebuild and restart the app.
+
+  • Run the packager with \`--reset-cache\` flag.
+
+  • If you are using CocoaPods on iOS, run \`pod install\` in the \`ios\` directory and then rebuild and re-run the app.
+
+  • If this happens while testing with Jest, check out docs how to integrate AsyncStorage with it: https://react-native-async-storage.github.io/async-storage/docs/advanced/jest
+
+If none of these fix the issue, please open an issue on the Github repository: https://github.com/react-native-async-storage/async-storage/issues
+`);
+}
+
+/**
+ * `AsyncStorage` is a simple, unencrypted, asynchronous, persistent, key-value
+ * storage system that is global to the app. It should be used instead of
+ * LocalStorage.
+ *
+ * See https://react-native-async-storage.github.io/async-storage/docs/api
+ */
+const AsyncStorage = ((): AsyncStorageStatic => {
+  let _getRequests: MultiRequest[] = [];
+  let _getKeys: string[] = [];
+  let _immediate: ReturnType<typeof setImmediate> | null = null;
+
+  return {
+    /**
+     * Fetches an item for a `key` and invokes a callback upon completion.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#getitem
+     */
+    getItem: (key, callback) => {
+      return new Promise((resolve, reject) => {
+        checkValidInput(key);
+        RCTAsyncStorage.multiGet(
+          [key],
+          (errors?: ErrorLike[], result?: string[][]) => {
+            // Unpack result to get value from [[key,value]]
+            const value = result?.[0]?.[1] ? result[0][1] : null;
+            const errs = convertErrors(errors);
+            callback?.(errs?.[0], value);
+            if (errs) {
+              reject(errs[0]);
+            } else {
+              resolve(value);
+            }
+          }
+        );
+      });
+    },
+
+    /**
+     * Sets the value for a `key` and invokes a callback upon completion.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#setitem
+     */
+    setItem: (key, value, callback) => {
+      return new Promise((resolve, reject) => {
+        checkValidInput(key, value);
+        RCTAsyncStorage.multiSet([[key, value]], (errors?: ErrorLike[]) => {
+          const errs = convertErrors(errors);
+          callback?.(errs?.[0]);
+          if (errs) {
+            reject(errs[0]);
+          } else {
+            resolve();
+          }
+        });
+      });
+    },
+
+    /**
+     * Removes an item for a `key` and invokes a callback upon completion.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#removeitem
+     */
+    removeItem: (key, callback) => {
+      return new Promise((resolve, reject) => {
+        checkValidInput(key);
+        RCTAsyncStorage.multiRemove([key], (errors?: ErrorLike[]) => {
+          const errs = convertErrors(errors);
+          callback?.(errs?.[0]);
+          if (errs) {
+            reject(errs[0]);
+          } else {
+            resolve();
+          }
+        });
+      });
+    },
+
+    /**
+     * Merges an existing `key` value with an input value, assuming both values
+     * are stringified JSON.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#mergeitem
+     */
+    mergeItem: (key, value, callback) => {
+      return new Promise((resolve, reject) => {
+        checkValidInput(key, value);
+        RCTAsyncStorage.multiMerge([[key, value]], (errors?: ErrorLike[]) => {
+          const errs = convertErrors(errors);
+          callback?.(errs?.[0]);
+          if (errs) {
+            reject(errs[0]);
+          } else {
+            resolve();
+          }
+        });
+      });
+    },
+
+    /**
+     * Erases *all* `AsyncStorage` for all clients, libraries, etc. You probably
+     * don't want to call this; use `removeItem` or `multiRemove` to clear only
+     * your app's keys.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#clear
+     */
+    clear: (callback) => {
+      return new Promise((resolve, reject) => {
+        RCTAsyncStorage.clear((error?: ErrorLike) => {
+          const err = convertError(error);
+          callback?.(err);
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    },
+
+    /**
+     * Gets *all* keys known to your app; for all callers, libraries, etc.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#getallkeys
+     */
+    getAllKeys: (callback) => {
+      return new Promise((resolve, reject) => {
+        RCTAsyncStorage.getAllKeys((error?: ErrorLike, keys?: string[]) => {
+          const err = convertError(error);
+          callback?.(err, keys);
+          if (keys) {
+            resolve(keys);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    },
+
+    /**
+     * The following batched functions are useful for executing a lot of
+     * operations at once, allowing for native optimizations and provide the
+     * convenience of a single callback after all operations are complete.
+     *
+     * These functions return arrays of errors, potentially one for every key.
+     * For key-specific errors, the Error object will have a key property to
+     * indicate which key caused the error.
+     */
+
+    /**
+     * Flushes any pending requests using a single batch call to get the data.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#flushgetrequests
+     * */
+    flushGetRequests: () => {
+      const getRequests = _getRequests;
+      const getKeys = _getKeys;
+
+      _getRequests = [];
+      _getKeys = [];
+
+      RCTAsyncStorage.multiGet(
+        getKeys,
+        (errors?: ErrorLike[], result?: string[][]) => {
+          // Even though the runtime complexity of this is theoretically worse vs if we used a map,
+          // it's much, much faster in practice for the data sets we deal with (we avoid
+          // allocating result pair arrays). This was heavily benchmarked.
+          //
+          // Is there a way to avoid using the map but fix the bug in this breaking test?
+          // https://github.com/facebook/react-native/commit/8dd8ad76579d7feef34c014d387bf02065692264
+          const map: Record<string, string> = {};
+          result?.forEach(([key, value]) => {
+            map[key] = value;
+            return value;
+          });
+          const reqLength = getRequests.length;
+
+          /**
+           * As mentioned few lines above, this method could be called with the array of potential error,
+           * in case of anything goes wrong. The problem is, if any of the batched calls fails
+           * the rest of them would fail too, but the error would be consumed by just one. The rest
+           * would simply return `undefined` as their result, rendering false negatives.
+           *
+           * In order to avoid this situation, in case of any call failing,
+           * the rest of them will be rejected as well (with the same error).
+           */
+          const errorList = convertErrors(errors);
+          const error = errorList?.length ? errorList[0] : null;
+
+          for (let i = 0; i < reqLength; i++) {
+            const request = getRequests[i];
+            if (error) {
+              request.callback?.(errorList);
+              request.reject?.(error);
+              continue;
+            }
+            const requestResult = request.keys.map<KeyValuePair>((key) => [
+              key,
+              map[key],
+            ]);
+            request.callback?.(null, requestResult);
+            request.resolve?.(requestResult);
+          }
+        }
+      );
+    },
+
+    /**
+     * This allows you to batch the fetching of items given an array of `key`
+     * inputs. Your callback will be invoked with an array of corresponding
+     * key-value pairs found.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#multiget
+     */
+    multiGet: (keys, callback) => {
+      if (!_immediate) {
+        _immediate = setImmediate(() => {
+          _immediate = null;
+          AsyncStorage.flushGetRequests();
+        });
+      }
+
+      const getRequest: MultiRequest = {
+        keys: keys,
+        callback: callback,
+        // do we need this?
+        keyIndex: _getKeys.length,
+        resolve: null as any,
+        reject: null as any,
+      };
+
+      const promiseResult = new Promise<readonly KeyValuePair[]>(
+        (resolve, reject) => {
+          getRequest.resolve = resolve;
+          getRequest.reject = reject;
+        }
+      );
+
+      _getRequests.push(getRequest);
+      // avoid fetching duplicates
+      keys.forEach((key) => {
+        if (_getKeys.indexOf(key) === -1) {
+          _getKeys.push(key);
+        }
+      });
+
+      return promiseResult;
+    },
+
+    /**
+     * Use this as a batch operation for storing multiple key-value pairs. When
+     * the operation completes you'll get a single callback with any errors.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#multiset
+     */
+    multiSet: (keyValuePairs, callback) => {
+      checkValidArgs(keyValuePairs, callback);
+      return new Promise((resolve, reject) => {
+        keyValuePairs.forEach(([key, value]) => {
+          checkValidInput(key, value);
+        });
+
+        RCTAsyncStorage.multiSet(keyValuePairs, (errors?: ErrorLike[]) => {
+          const error = convertErrors(errors);
+          callback?.(error);
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    },
+
+    /**
+     * Call this to batch the deletion of all keys in the `keys` array.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#multiremove
+     */
+    multiRemove: (keys, callback) => {
+      return new Promise((resolve, reject) => {
+        keys.forEach((key) => checkValidInput(key));
+
+        RCTAsyncStorage.multiRemove(keys, (errors?: ErrorLike[]) => {
+          const error = convertErrors(errors);
+          callback?.(error);
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    },
+
+    /**
+     * Batch operation to merge in existing and new values for a given set of
+     * keys. This assumes that the values are stringified JSON.
+     *
+     * See https://react-native-async-storage.github.io/async-storage/docs/api#multimerge
+     */
+    multiMerge: (keyValuePairs, callback) => {
+      return new Promise((resolve, reject) => {
+        RCTAsyncStorage.multiMerge(keyValuePairs, (errors?: ErrorLike[]) => {
+          const error = convertErrors(errors);
+          callback?.(error);
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    },
+  };
+})();
+
+export default AsyncStorage;