Version 1.0.2 mit node_modules Verzeichnis

node_modules/recoil/cjs/adt/__tests__/Recoil_ArrayKeyedMap-test.js.flow

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall recoil
+ */
+
+'use strict';
+
+const {ArrayKeyedMap} = require('../Recoil_ArrayKeyedMap');
+
+test('basic operation', () => {
+  const m = new ArrayKeyedMap<number>();
+  m.set([], 0);
+  m.set(['a'], 1);
+  m.set(['a', 'b'], 2);
+  expect(m.get([])).toBe(0);
+  expect(m.get(['a'])).toBe(1);
+  expect(m.get(['a', 'b'])).toBe(2);
+});
+
+test('enumeration of properties', () => {
+  const m = new ArrayKeyedMap<number>();
+  m.set([], 0);
+  m.set(['a'], 1);
+  m.set(['a', 'b'], 2);
+  const entries = Array.from(m.entries());
+  expect(entries[0][0]).toEqual([]);
+  expect(entries[0][1]).toBe(0);
+  expect(entries[1][0]).toEqual(['a']);
+  expect(entries[1][1]).toBe(1);
+  expect(entries[2][0]).toEqual(['a', 'b']);
+  expect(entries[2][1]).toBe(2);
+});
+
+test('copying', () => {
+  const m = new ArrayKeyedMap<number | $FlowFixMe>();
+  m.set([], 0);
+  m.set(['a'], 1);
+  m.set(['a', 'b'], 2);
+  const mm = new ArrayKeyedMap(m);
+  expect(mm.get([])).toBe(0);
+  expect(mm.get(['a'])).toBe(1);
+  expect(mm.get(['a', 'b'])).toBe(2);
+  expect(Array.from(m.entries())).toEqual(Array.from(mm.entries()));
+});

node_modules/recoil/cjs/adt/__tests__/Recoil_Loadable-test.js.flow

@@ -0,0 +1,281 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall recoil
+ */
+
+'use strict';
+
+const {
+  RecoilLoadable,
+  loadableWithError,
+  loadableWithPromise,
+  loadableWithValue,
+} = require('../Recoil_Loadable');
+
+const ERROR = new Error('ERROR');
+
+test('Value Loadable', async () => {
+  const loadable = loadableWithValue('VALUE');
+  expect(loadable.state).toBe('hasValue');
+  expect(loadable.contents).toBe('VALUE');
+  expect(loadable.getValue()).toBe('VALUE');
+  await expect(loadable.toPromise()).resolves.toBe('VALUE');
+  expect(loadable.valueMaybe()).toBe('VALUE');
+  expect(loadable.valueOrThrow()).toBe('VALUE');
+  expect(loadable.errorMaybe()).toBe(undefined);
+  expect(() => loadable.errorOrThrow()).toThrow();
+  expect(loadable.promiseMaybe()).toBe(undefined);
+  expect(() => loadable.promiseOrThrow()).toThrow();
+});
+
+test('Error Loadable', async () => {
+  const loadable = loadableWithError<$FlowFixMe>(ERROR);
+  expect(loadable.state).toBe('hasError');
+  expect(loadable.contents).toBe(ERROR);
+  expect(() => loadable.getValue()).toThrow(ERROR);
+  await expect(loadable.toPromise()).rejects.toBe(ERROR);
+  expect(loadable.valueMaybe()).toBe(undefined);
+  expect(() => loadable.valueOrThrow()).toThrow();
+  expect(loadable.errorMaybe()).toBe(ERROR);
+  expect(loadable.errorOrThrow()).toBe(ERROR);
+  expect(loadable.promiseMaybe()).toBe(undefined);
+  expect(() => loadable.promiseOrThrow()).toThrow();
+});
+
+test('Pending Value Loadable', async () => {
+  const promise = Promise.resolve('VALUE');
+  const loadable = loadableWithPromise(promise);
+  expect(loadable.state).toBe('loading');
+  expect(loadable.contents).toBe(promise);
+  expect(() => loadable.getValue()).toThrow();
+  await expect(loadable.toPromise()).resolves.toBe('VALUE');
+  expect(loadable.valueMaybe()).toBe(undefined);
+  expect(() => loadable.valueOrThrow()).toThrow();
+  expect(loadable.errorMaybe()).toBe(undefined);
+  expect(() => loadable.errorOrThrow()).toThrow();
+  await expect(loadable.promiseMaybe()).resolves.toBe('VALUE');
+  await expect(loadable.promiseOrThrow()).resolves.toBe('VALUE');
+});
+
+describe('Loadable mapping', () => {
+  test('Loadable mapping value', () => {
+    const loadable = loadableWithValue('VALUE').map(x => 'MAPPED ' + x);
+    expect(loadable.state).toBe('hasValue');
+    expect(loadable.contents).toBe('MAPPED VALUE');
+  });
+
+  test('Loadable mapping value to error', () => {
+    const loadable = loadableWithValue('VALUE').map<$FlowFixMe>(() => {
+      throw ERROR;
+    });
+    expect(loadable.state).toBe('hasError');
+    expect(loadable.contents).toBe(ERROR);
+  });
+
+  test('Loadable mapping value to Promise', async () => {
+    const loadable = loadableWithValue('VALUE').map(value =>
+      Promise.resolve('MAPPED ' + value),
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).resolves.toBe('MAPPED VALUE');
+  });
+
+  test('Loadable mapping value to reject', async () => {
+    const loadable = loadableWithValue('VALUE').map(() =>
+      Promise.reject(ERROR),
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).rejects.toBe(ERROR);
+  });
+
+  test('Loadable mapping error', () => {
+    const loadable = loadableWithError<mixed>(ERROR).map(() => 'NOT_USED');
+    expect(loadable.state).toBe('hasError');
+    expect(loadable.contents).toBe(ERROR);
+  });
+
+  test('Loadable mapping promise value', async () => {
+    const loadable = loadableWithPromise(Promise.resolve('VALUE')).map(
+      x => 'MAPPED ' + x,
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).resolves.toBe('MAPPED VALUE');
+  });
+
+  test('Loadable mapping promise value to reject', async () => {
+    const loadable = loadableWithPromise(Promise.resolve('VALUE')).map(() =>
+      Promise.reject(ERROR),
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).rejects.toBe(ERROR);
+  });
+  test('Loadable mapping promise value to error', async () => {
+    const loadable = loadableWithPromise(Promise.resolve('VALUE')).map<mixed>(
+      () => {
+        throw ERROR;
+      },
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).rejects.toBe(ERROR);
+  });
+
+  test('Loadable mapping promise error', async () => {
+    const loadable = loadableWithPromise(Promise.reject(ERROR)).map(
+      () => 'NOT_USED',
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).rejects.toBe(ERROR);
+  });
+
+  test('Loadable mapping to loadable', () => {
+    const loadable = loadableWithValue('VALUE').map(value =>
+      loadableWithValue(value),
+    );
+    expect(loadable.state).toBe('hasValue');
+    expect(loadable.contents).toBe('VALUE');
+  });
+
+  test('Loadable mapping promise to loadable value', async () => {
+    const loadable = loadableWithPromise(Promise.resolve('VALUE')).map(value =>
+      loadableWithValue('MAPPED ' + value),
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).resolves.toBe('MAPPED VALUE');
+  });
+
+  test('Loadable mapping promise to loadable error', async () => {
+    const loadable = loadableWithPromise(Promise.resolve('VALUE')).map(() =>
+      // $FlowFixMe[underconstrained-implicit-instantiation]
+      loadableWithError(ERROR),
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).rejects.toBe(ERROR);
+  });
+
+  test('Loadable mapping promise to loadable promise', async () => {
+    const loadable = loadableWithPromise(Promise.resolve('VALUE')).map(value =>
+      loadableWithPromise(Promise.resolve('MAPPED ' + value)),
+    );
+    expect(loadable.state).toBe('loading');
+    await expect(loadable.toPromise()).resolves.toBe('MAPPED VALUE');
+  });
+});
+
+test('Loadable Factory Interface', async () => {
+  const valueLoadable = RecoilLoadable.of('VALUE');
+  expect(valueLoadable.state).toBe('hasValue');
+  expect(valueLoadable.contents).toBe('VALUE');
+  const valueLoadable2 = RecoilLoadable.of(RecoilLoadable.of('VALUE'));
+  expect(valueLoadable2.state).toBe('hasValue');
+  expect(valueLoadable2.contents).toBe('VALUE');
+
+  const promiseLoadable = RecoilLoadable.of(Promise.resolve('ASYNC'));
+  expect(promiseLoadable.state).toBe('loading');
+  await expect(promiseLoadable.contents).resolves.toBe('ASYNC');
+  const promiseLoadable2 = RecoilLoadable.of(
+    RecoilLoadable.of(Promise.resolve('ASYNC')),
+  );
+  expect(promiseLoadable2.state).toBe('loading');
+  await expect(promiseLoadable2.contents).resolves.toBe('ASYNC');
+
+  const errorLoadable = RecoilLoadable.error<mixed>('ERROR');
+  expect(errorLoadable.state).toBe('hasError');
+  expect(errorLoadable.contents).toBe('ERROR');
+  // $FlowFixMe[underconstrained-implicit-instantiation]
+  const errorLoadable2 = RecoilLoadable.of(RecoilLoadable.error('ERROR'));
+  expect(errorLoadable2.state).toBe('hasError');
+  expect(errorLoadable2.contents).toBe('ERROR');
+
+  const loadingLoadable = RecoilLoadable.loading<mixed>();
+  expect(loadingLoadable.state).toBe('loading');
+});
+
+describe('Loadable All', () => {
+  test('Array', async () => {
+    expect(
+      RecoilLoadable.all([RecoilLoadable.of('x'), RecoilLoadable.of(123)])
+        .contents,
+    ).toEqual(['x', 123]);
+    await expect(
+      RecoilLoadable.all([
+        RecoilLoadable.of(Promise.resolve('x')),
+        RecoilLoadable.of(123),
+      ]).contents,
+    ).resolves.toEqual(['x', 123]);
+    expect(
+      RecoilLoadable.all([
+        RecoilLoadable.of('x'),
+        RecoilLoadable.of(123),
+        // $FlowFixMe[underconstrained-implicit-instantiation]
+        RecoilLoadable.error('ERROR'),
+      ]).contents,
+    ).toEqual('ERROR');
+
+    expect(
+      RecoilLoadable.all([
+        RecoilLoadable.of('x'),
+        RecoilLoadable.all([RecoilLoadable.of(1), RecoilLoadable.of(2)]),
+      ]).contents,
+    ).toEqual(['x', [1, 2]]);
+  });
+
+  test('Object', async () => {
+    expect(
+      RecoilLoadable.all({
+        str: RecoilLoadable.of('x'),
+        num: RecoilLoadable.of(123),
+      }).contents,
+    ).toEqual({
+      str: 'x',
+      num: 123,
+    });
+    await expect(
+      RecoilLoadable.all({
+        str: RecoilLoadable.of(Promise.resolve('x')),
+        num: RecoilLoadable.of(123),
+      }).contents,
+    ).resolves.toEqual({
+      str: 'x',
+      num: 123,
+    });
+    expect(
+      RecoilLoadable.all({
+        str: RecoilLoadable.of('x'),
+        num: RecoilLoadable.of(123),
+        // $FlowFixMe[underconstrained-implicit-instantiation]
+        err: RecoilLoadable.error('ERROR'),
+      }).contents,
+    ).toEqual('ERROR');
+  });
+
+  test('mixed values', async () => {
+    expect(RecoilLoadable.all([RecoilLoadable.of('A'), 'B']).contents).toEqual([
+      'A',
+      'B',
+    ]);
+
+    await expect(
+      RecoilLoadable.all([RecoilLoadable.of('A'), Promise.resolve('B')])
+        .contents,
+    ).resolves.toEqual(['A', 'B']);
+
+    await expect(
+      RecoilLoadable.all([RecoilLoadable.of('A'), Promise.reject('B')])
+        .contents,
+    ).rejects.toEqual('B');
+
+    await expect(
+      RecoilLoadable.all({
+        a: 'A',
+        b: RecoilLoadable.of('B'),
+        c: Promise.resolve('C'),
+      }).contents,
+    ).resolves.toEqual({a: 'A', b: 'B', c: 'C'});
+  });
+});