···

       
16
       
 
       
    "./package.json": "./package.json"

     

       
17
       
 
       
  },

     

       
18
       
 
       
  "dependencies": {

     

       
19
       
-
       
    "@urql/core": ">=3.1.1",

     

       
20
       
 
       
    "wonka": "^6.0.0"

     

       
21
       
 
       
  }

     

       
22
       
 
       
}

     

···

       
16
       
 
       
    "./package.json": "./package.json"

     

       
17
       
 
       
  },

     

       
18
       
 
       
  "dependencies": {

     

       
19
       
+
       
    "@urql/core": ">=3.2.2",

     

       
20
       
 
       
    "wonka": "^6.0.0"

     

       
21
       
 
       
  }

     

       
22
       
 
       
}

     

···

       
21
       
 
       
} from 'wonka';

     

       
22
       
 
       


     

       
23
       
 
       
import { query, write, writeOptimistic } from './operations';

     

       
24
       
-
       
import { addCacheOutcome, toRequestPolicy } from './helpers/operation';

     

       
25
       
 
       
import { filterVariables, getMainOperation } from './ast';

     

       
26
       
 
       
import { Store, noopDataState, hydrateData, reserveLayer } from './store';

     

       
27
       
 
       
import { Data, Dependencies, CacheExchangeOpts } from './types';

     
···

       
295
       
 
       
          message: 'The result could not be retrieved from the cache',

     

       
296
       
 
       
          operation: res.operation,

     

       
297
       
 
       
        });

     

       
298
       
-
       
        return addCacheOutcome(res.operation, 'miss');

     

       
299
       
 
       
      })

     

       
300
       
 
       
    );

     

       
301
       
 
       


     
···

       
327
       
 
       
              !reexecutingOperations.has(res.operation.key));

     

       
328
       
 
       


     

       
329
       
 
       
          const result: OperationResult = {

     

       
330
       
-
       
            operation: addCacheOutcome(res.operation, res.outcome),

     

       
0
       
 
       

     

       
0
       
 
       

     

       
331
       
 
       
            data: res.data,

     

       
332
       
 
       
            error: res.error,

     

       
333
       
 
       
            extensions: res.extensions,

     

···

       
21
       
 
       
} from 'wonka';

     

       
22
       
 
       


     

       
23
       
 
       
import { query, write, writeOptimistic } from './operations';

     

       
24
       
+
       
import { addMetadata, toRequestPolicy } from './helpers/operation';

     

       
25
       
 
       
import { filterVariables, getMainOperation } from './ast';

     

       
26
       
 
       
import { Store, noopDataState, hydrateData, reserveLayer } from './store';

     

       
27
       
 
       
import { Data, Dependencies, CacheExchangeOpts } from './types';

     
···

       
295
       
 
       
          message: 'The result could not be retrieved from the cache',

     

       
296
       
 
       
          operation: res.operation,

     

       
297
       
 
       
        });

     

       
298
       
+
       
        return addMetadata(res.operation, { cacheOutcome: 'miss' });

     

       
299
       
 
       
      })

     

       
300
       
 
       
    );

     

       
301
       
 
       


     
···

       
327
       
 
       
              !reexecutingOperations.has(res.operation.key));

     

       
328
       
 
       


     

       
329
       
 
       
          const result: OperationResult = {

     

       
330
       
+
       
            operation: addMetadata(res.operation, {

     

       
331
       
+
       
              cacheOutcome: res.outcome,

     

       
332
       
+
       
            }),

     

       
333
       
 
       
            data: res.data,

     

       
334
       
 
       
            error: res.error,

     

       
335
       
 
       
            extensions: res.extensions,

     

···

       
1
       
 
       
import {

     

       
2
       
 
       
  Operation,

     

       
3
       
 
       
  RequestPolicy,

     

       
4
       
-
       
  CacheOutcome,

     

       
5
       
 
       
  makeOperation,

     

       
6
       
 
       
} from '@urql/core';

     

       
7
       
 
       


     

       
8
       
 
       
// Returns the given operation result with added cacheOutcome meta field

     

       
9
       
-
       
export const addCacheOutcome = (

     

       
10
       
 
       
  operation: Operation,

     

       
11
       
-
       
  outcome: CacheOutcome

     

       
12
       
 
       
): Operation =>

     

       
13
       
 
       
  makeOperation(operation.kind, operation, {

     

       
14
       
 
       
    ...operation.context,

     

       
15
       
 
       
    meta: {

     

       
16
       
 
       
      ...operation.context.meta,

     

       
17
       
-
       
      cacheOutcome: outcome,

     

       
18
       
 
       
    },

     

       
19
       
 
       
  });

     

       
20
       
 
       


     

···

       
1
       
 
       
import {

     

       
2
       
 
       
  Operation,

     

       
3
       
 
       
  RequestPolicy,

     

       
4
       
+
       
  OperationDebugMeta,

     

       
5
       
 
       
  makeOperation,

     

       
6
       
 
       
} from '@urql/core';

     

       
7
       
 
       


     

       
8
       
 
       
// Returns the given operation result with added cacheOutcome meta field

     

       
9
       
+
       
export const addMetadata = (

     

       
10
       
 
       
  operation: Operation,

     

       
11
       
+
       
  meta: OperationDebugMeta

     

       
12
       
 
       
): Operation =>

     

       
13
       
 
       
  makeOperation(operation.kind, operation, {

     

       
14
       
 
       
    ...operation.context,

     

       
15
       
 
       
    meta: {

     

       
16
       
 
       
      ...operation.context.meta,

     

       
17
       
+
       
      ...meta,

     

       
18
       
 
       
    },

     

       
19
       
 
       
  });

     

       
20
       
 
       


     

···

       
3
       
 
       
import { AnyVariables, TypedDocumentNode } from './types';

     

       
4
       
 
       
import { keyDocument, stringifyDocument } from './utils';

     

       
5
       
 
       


     

       
6
       
-
       
const applyDefinitions = (

     

       
7
       
-
       
  fragmentNames: Map<string, string>,

     

       
8
       
-
       
  target: DefinitionNode[],

     

       
9
       
-
       
  source: Array<DefinitionNode> | ReadonlyArray<DefinitionNode>

     

       
10
       
-
       
) => {

     

       
11
       
-
       
  for (const definition of source) {

     

       
12
       
-
       
    if (definition.kind === Kind.FRAGMENT_DEFINITION) {

     

       
13
       
-
       
      const name = definition.name.value;

     

       
14
       
-
       
      const value = stringifyDocument(definition);

     

       
15
       
-
       
      // Fragments will be deduplicated according to this Map

     

       
16
       
-
       
      if (!fragmentNames.has(name)) {

     

       
17
       
-
       
        fragmentNames.set(name, value);

     

       
18
       
-
       
        target.push(definition);

     

       
19
       
-
       
      } else if (

     

       
20
       
-
       
        process.env.NODE_ENV !== 'production' &&

     

       
21
       
-
       
        fragmentNames.get(name) !== value

     

       
22
       
-
       
      ) {

     

       
23
       
-
       
        // Fragments with the same names is expected to have the same contents

     

       
24
       
-
       
        console.warn(

     

       
25
       
-
       
          '[WARNING: Duplicate Fragment] A fragment with name `' +

     

       
26
       
-
       
            name +

     

       
27
       
-
       
            '` already exists in this document.\n' +

     

       
28
       
-
       
            'While fragment names may not be unique across your source, each name must be unique per document.'

     

       
29
       
-
       
        );

     

       
30
       
-
       
      }

     

       
31
       
-
       
    } else {

     

       
32
       
-
       
      target.push(definition);

     

       
33
       
-
       
    }

     

       
34
       
-
       
  }

     

       
35
       
-
       
};

     

       
36
       
-
       


     

       
37
       
 
       
/** A GraphQL parse function, which may be called as a tagged template literal, returning a parsed {@link DocumentNode}.

     

       
38
       
 
       
 *

     

       
39
       
 
       
 * @remarks

     
···

       
89
       
 
       
  string: string

     

       
90
       
 
       
): TypedDocumentNode<Data, Variables>;

     

       
91
       
 
       


     

       
92
       
-
       
function gql(/* arguments */) {

     

       
93
       
 
       
  const fragmentNames = new Map<string, string>();

     

       
94
       
 
       
  const definitions: DefinitionNode[] = [];

     

       
95
       
-
       
  const interpolations: DefinitionNode[] = [];

     

       
96
       
 
       


     

       
97
       
 
       
  // Apply the entire tagged template body's definitions

     

       
98
       
-
       
  let body: string = Array.isArray(arguments[0])

     

       
99
       
-
       
    ? arguments[0][0]

     

       
100
       
-
       
    : arguments[0] || '';

     

       
101
       
 
       
  for (let i = 1; i < arguments.length; i++) {

     

       
102
       
 
       
    const value = arguments[i];

     

       
103
       
 
       
    if (value && value.definitions) {

     

       
104
       
-
       
      interpolations.push(...value.definitions);

     

       
105
       
 
       
    } else {

     

       
106
       
 
       
      body += value;

     

       
107
       
 
       
    }

     
···

       
109
       
 
       
    body += arguments[0][i];

     

       
110
       
 
       
  }

     

       
111
       
 
       


     

       
112
       
-
       
  // Apply the tag's body definitions

     

       
113
       
-
       
  applyDefinitions(fragmentNames, definitions, keyDocument(body).definitions);

     

       
114
       
-
       
  // Copy over each interpolated document's definitions

     

       
115
       
-
       
  applyDefinitions(fragmentNames, definitions, interpolations);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
116
       
 
       


     

       
117
       
 
       
  return keyDocument({

     

       
118
       
 
       
    kind: Kind.DOCUMENT,

     

···

       
3
       
 
       
import { AnyVariables, TypedDocumentNode } from './types';

     

       
4
       
 
       
import { keyDocument, stringifyDocument } from './utils';

     

       
5
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       
/** A GraphQL parse function, which may be called as a tagged template literal, returning a parsed {@link DocumentNode}.

     

       
7
       
 
       
 *

     

       
8
       
 
       
 * @remarks

     
···

       
58
       
 
       
  string: string

     

       
59
       
 
       
): TypedDocumentNode<Data, Variables>;

     

       
60
       
 
       


     

       
61
       
+
       
function gql(parts: string | TemplateStringsArray /* arguments */) {

     

       
62
       
 
       
  const fragmentNames = new Map<string, string>();

     

       
63
       
 
       
  const definitions: DefinitionNode[] = [];

     

       
64
       
+
       
  const source: DocumentNode[] = [];

     

       
65
       
 
       


     

       
66
       
 
       
  // Apply the entire tagged template body's definitions

     

       
67
       
+
       
  let body: string = Array.isArray(parts) ? parts[0] : parts || '';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
68
       
 
       
  for (let i = 1; i < arguments.length; i++) {

     

       
69
       
 
       
    const value = arguments[i];

     

       
70
       
 
       
    if (value && value.definitions) {

     

       
71
       
+
       
      source.push(value);

     

       
72
       
 
       
    } else {

     

       
73
       
 
       
      body += value;

     

       
74
       
 
       
    }

     
···

       
76
       
 
       
    body += arguments[0][i];

     

       
77
       
 
       
  }

     

       
78
       
 
       


     

       
79
       
+
       
  source.unshift(keyDocument(body));

     

       
80
       
+
       
  for (const document of source) {

     

       
81
       
+
       
    for (const definition of document.definitions) {

     

       
82
       
+
       
      if (definition.kind === Kind.FRAGMENT_DEFINITION) {

     

       
83
       
+
       
        const name = definition.name.value;

     

       
84
       
+
       
        const value = stringifyDocument(definition);

     

       
85
       
+
       
        // Fragments will be deduplicated according to this Map

     

       
86
       
+
       
        if (!fragmentNames.has(name)) {

     

       
87
       
+
       
          fragmentNames.set(name, value);

     

       
88
       
+
       
          definitions.push(definition);

     

       
89
       
+
       
        } else if (

     

       
90
       
+
       
          process.env.NODE_ENV !== 'production' &&

     

       
91
       
+
       
          fragmentNames.get(name) !== value

     

       
92
       
+
       
        ) {

     

       
93
       
+
       
          // Fragments with the same names is expected to have the same contents

     

       
94
       
+
       
          console.warn(

     

       
95
       
+
       
            '[WARNING: Duplicate Fragment] A fragment with name `' +

     

       
96
       
+
       
              name +

     

       
97
       
+
       
              '` already exists in this document.\n' +

     

       
98
       
+
       
              'While fragment names may not be unique across your source, each name must be unique per document.'

     

       
99
       
+
       
          );

     

       
100
       
+
       
        }

     

       
101
       
+
       
      } else {

     

       
102
       
+
       
        definitions.push(definition);

     

       
103
       
+
       
      }

     

       
104
       
+
       
    }

     

       
105
       
+
       
  }

     

       
106
       
 
       


     

       
107
       
 
       
  return keyDocument({

     

       
108
       
 
       
    kind: Kind.DOCUMENT,

     

···

       
433
       
 
       
   * `OperationResult`s and is filled in by exchanges across the codebase in development.

     

       
434
       
 
       
   *

     

       
435
       
 
       
   * This data is not for production use and hence shouldn't be used or relied upon directly.

     

       
0
       
 
       

     

       
436
       
 
       
   */

     

       
437
       
 
       
  meta?: OperationDebugMeta;

     

       
438
       
 
       
  /** Instructs fetch exchanges to use a GET request.

     

···

       
433
       
 
       
   * `OperationResult`s and is filled in by exchanges across the codebase in development.

     

       
434
       
 
       
   *

     

       
435
       
 
       
   * This data is not for production use and hence shouldn't be used or relied upon directly.

     

       
436
       
+
       
   * In production, this may not be set by default exchanges.

     

       
437
       
 
       
   */

     

       
438
       
 
       
  meta?: OperationDebugMeta;

     

       
439
       
 
       
  /** Instructs fetch exchanges to use a GET request.

     

···

       
30
       
 
       
 * @see {@link http://www.cse.yorku.ca/~oz/hash.html#djb2} for a further description of djb2.

     

       
31
       
 
       
 */

     

       
32
       
 
       
export const phash = (x: string, seed?: HashValue): HashValue => {

     

       
33
       
-
       
  let h = typeof seed === 'number' ? seed | 0 : 5381;

     

       
34
       
 
       
  for (let i = 0, l = x.length | 0; i < l; i++)

     

       
35
       
 
       
    h = (h << 5) + h + x.charCodeAt(i);

     

       
36
       
 
       
  return h as HashValue;

     

···

       
30
       
 
       
 * @see {@link http://www.cse.yorku.ca/~oz/hash.html#djb2} for a further description of djb2.

     

       
31
       
 
       
 */

     

       
32
       
 
       
export const phash = (x: string, seed?: HashValue): HashValue => {

     

       
33
       
+
       
  let h = (seed || 5381) | 0;

     

       
34
       
 
       
  for (let i = 0, l = x.length | 0; i < l; i++)

     

       
35
       
 
       
    h = (h << 5) + h + x.charCodeAt(i);

     

       
36
       
 
       
  return h as HashValue;

     

···

       
24
       
 
       


     

       
25
       
 
       
const SOURCE_NAME = 'gql';

     

       
26
       
 
       
const GRAPHQL_STRING_RE = /("{3}[\s\S]*"{3}|"(?:\\.|[^"])*")/g;

     

       
27
       
-
       
const REPLACE_CHAR_RE = /(#[^\n\r]+)?(?:\n|\r\n?|$)+/g;

     

       
28
       
 
       


     

       
29
       
 
       
const replaceOutsideStrings = (str: string, idx: number) =>

     

       
30
       
 
       
  idx % 2 === 0 ? str.replace(REPLACE_CHAR_RE, '\n') : str;

     
···

       
95
       
 
       
): HashValue => {

     

       
96
       
 
       
  let key = phash(stringifyDocument(node));

     

       
97
       
 
       
  // Add the operation name to the produced hash

     

       
98
       
-
       
  if (typeof node === 'object' && 'definitions' in node) {

     

       
99
       
-
       
    const operationName = getOperationName(node);

     

       
100
       
 
       
    if (operationName) key = phash(`\n# ${operationName}`, key);

     

       
101
       
 
       
  }

     

       
102
       
 
       
  return key;

     
···

       
151
       
 
       
  Data = any,

     

       
152
       
 
       
  Variables extends AnyVariables = AnyVariables

     

       
153
       
 
       
>(

     

       
154
       
-
       
  q: string | DocumentNode | TypedDocumentNode<Data, Variables>,

     

       
155
       
-
       
  variables: Variables

     

       
156
       
 
       
): GraphQLRequest<Data, Variables> => {

     

       
157
       
-
       
  if (!variables) variables = {} as Variables;

     

       
158
       
-
       
  const query = keyDocument(q);

     

       
159
       
 
       
  const printedVars = stringifyVariables(variables);

     

       
160
       
 
       
  let key = query.__key;

     

       
161
       
 
       
  if (printedVars !== '{}') key = phash(printedVars, key);

     

···

       
24
       
 
       


     

       
25
       
 
       
const SOURCE_NAME = 'gql';

     

       
26
       
 
       
const GRAPHQL_STRING_RE = /("{3}[\s\S]*"{3}|"(?:\\.|[^"])*")/g;

     

       
27
       
+
       
const REPLACE_CHAR_RE = /(?:#[^\n\r]+)?(?:[\r\n]+|$)/g;

     

       
28
       
 
       


     

       
29
       
 
       
const replaceOutsideStrings = (str: string, idx: number) =>

     

       
30
       
 
       
  idx % 2 === 0 ? str.replace(REPLACE_CHAR_RE, '\n') : str;

     
···

       
95
       
 
       
): HashValue => {

     

       
96
       
 
       
  let key = phash(stringifyDocument(node));

     

       
97
       
 
       
  // Add the operation name to the produced hash

     

       
98
       
+
       
  if ((node as DocumentNode).definitions) {

     

       
99
       
+
       
    const operationName = getOperationName(node as DocumentNode);

     

       
100
       
 
       
    if (operationName) key = phash(`\n# ${operationName}`, key);

     

       
101
       
 
       
  }

     

       
102
       
 
       
  return key;

     
···

       
151
       
 
       
  Data = any,

     

       
152
       
 
       
  Variables extends AnyVariables = AnyVariables

     

       
153
       
 
       
>(

     

       
154
       
+
       
  _query: string | DocumentNode | TypedDocumentNode<Data, Variables>,

     

       
155
       
+
       
  _variables: Variables

     

       
156
       
 
       
): GraphQLRequest<Data, Variables> => {

     

       
157
       
+
       
  const variables = _variables || ({} as Variables);

     

       
158
       
+
       
  const query = keyDocument(_query);

     

       
159
       
 
       
  const printedVars = stringifyVariables(variables);

     

       
160
       
 
       
  let key = query.__key;

     

       
161
       
 
       
  if (printedVars !== '{}') key = phash(printedVars, key);

     

···

       
28
       
 
       
  result: ExecutionResult,

     

       
29
       
 
       
  response?: any

     

       
30
       
 
       
): OperationResult => {

     

       
31
       
-
       
  if (

     

       
32
       
-
       
    (!('data' in result) && !('errors' in result)) ||

     

       
33
       
-
       
    'incremental' in result

     

       
34
       
-
       
  ) {

     

       
35
       
 
       
    throw new Error('No Content');

     

       
36
       
 
       
  }

     

       
37
       
 
       


     
···

       
45
       
 
       
          response,

     

       
46
       
 
       
        })

     

       
47
       
 
       
      : undefined,

     

       
48
       
-
       
    extensions:

     

       
49
       
-
       
      (typeof result.extensions === 'object' && result.extensions) || undefined,

     

       
50
       
 
       
    hasNext: result.hasNext == null ? defaultHasNext : result.hasNext,

     

       
51
       
 
       
  };

     

       
52
       
 
       
};

     
···

       
83
       
 
       


     

       
84
       
 
       
  // NOTE: We handle the old version of the incremental delivery payloads as well

     

       
85
       
 
       
  if ('path' in nextResult) {

     

       
86
       
-
       
    incremental = [

     

       
87
       
-
       
      {

     

       
88
       
-
       
        data: nextResult.data,

     

       
89
       
-
       
        path: nextResult.path,

     

       
90
       
-
       
      } as IncrementalPayload,

     

       
91
       
-
       
    ];

     

       
92
       
 
       
  }

     

       
93
       
 
       


     

       
94
       
 
       
  if (incremental) {

     

···

       
28
       
 
       
  result: ExecutionResult,

     

       
29
       
 
       
  response?: any

     

       
30
       
 
       
): OperationResult => {

     

       
31
       
+
       
  if (!('data' in result) && !('errors' in result)) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       
    throw new Error('No Content');

     

       
33
       
 
       
  }

     

       
34
       
 
       


     
···

       
42
       
 
       
          response,

     

       
43
       
 
       
        })

     

       
44
       
 
       
      : undefined,

     

       
45
       
+
       
    extensions: result.extensions ? { ...result.extensions } : undefined,

     

       
0
       
 
       

     

       
46
       
 
       
    hasNext: result.hasNext == null ? defaultHasNext : result.hasNext,

     

       
47
       
 
       
  };

     

       
48
       
 
       
};

     
···

       
79
       
 
       


     

       
80
       
 
       
  // NOTE: We handle the old version of the incremental delivery payloads as well

     

       
81
       
 
       
  if ('path' in nextResult) {

     

       
82
       
+
       
    incremental = [nextResult as IncrementalPayload];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
83
       
 
       
  }

     

       
84
       
 
       


     

       
85
       
 
       
  if (incremental) {

     

···

       
1
       
-
       
import { Source, subscribe, pipe } from 'wonka';

     

       
2
       
 
       
import { OperationResult, PromisifiedSource } from '../types';

     

       
3
       
 
       


     

       
4
       
 
       
/** Patches a `toPromise` method onto the `Source` passed to it.

     
···

       
9
       
 
       
export function withPromise<T extends OperationResult>(

     

       
10
       
 
       
  source$: Source<T>

     

       
11
       
 
       
): PromisifiedSource<T> {

     

       
12
       
-
       
  (source$ as PromisifiedSource<T>).toPromise = () => {

     

       
13
       
-
       
    return new Promise(resolve => {

     

       
14
       
-
       
      const subscription = pipe(

     

       
15
       
-
       
        source$,

     

       
16
       
-
       
        subscribe(result => {

     

       
17
       
-
       
          if (!result.stale && !result.hasNext) {

     

       
18
       
-
       
            Promise.resolve().then(() => {

     

       
19
       
-
       
              subscription.unsubscribe();

     

       
20
       
-
       
              resolve(result);

     

       
21
       
-
       
            });

     

       
22
       
-
       
          }

     

       
23
       
-
       
        })

     

       
24
       
-
       
      );

     

       
25
       
-
       
    });

     

       
26
       
-
       
  };

     

       
27
       
 
       


     

       
28
       
 
       
  return source$ as PromisifiedSource<T>;

     

       
29
       
 
       
}

     

···

       
1
       
+
       
import { Source, take, filter, toPromise, pipe } from 'wonka';

     

       
2
       
 
       
import { OperationResult, PromisifiedSource } from '../types';

     

       
3
       
 
       


     

       
4
       
 
       
/** Patches a `toPromise` method onto the `Source` passed to it.

     
···

       
9
       
 
       
export function withPromise<T extends OperationResult>(

     

       
10
       
 
       
  source$: Source<T>

     

       
11
       
 
       
): PromisifiedSource<T> {

     

       
12
       
+
       
  (source$ as PromisifiedSource<T>).toPromise = () =>

     

       
13
       
+
       
    pipe(

     

       
14
       
+
       
      source$,

     

       
15
       
+
       
      filter(result => !result.stale && !result.hasNext),

     

       
16
       
+
       
      take(1),

     

       
17
       
+
       
      toPromise

     

       
18
       
+
       
    );

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
19
       
 
       


     

       
20
       
 
       
  return source$ as PromisifiedSource<T>;

     

       
21
       
 
       
}

     

···

       
10
       
 
       
    return stringify(x.toJSON());

     

       
11
       
 
       
  } else if (Array.isArray(x)) {

     

       
12
       
 
       
    let out = '[';

     

       
13
       
-
       
    for (let value of x) {

     

       
14
       
-
       
      if (out !== '[') out += ',';

     

       
15
       
-
       
      value = stringify(value);

     

       
16
       
-
       
      out += value.length > 0 ? value : 'null';

     

       
17
       
 
       
    }

     

       
18
       
-
       


     

       
19
       
 
       
    out += ']';

     

       
20
       
 
       
    return out;

     

       
21
       
 
       
  }

     
···

       
24
       
 
       
  if (!keys.length && x.constructor && x.constructor !== Object) {

     

       
25
       
 
       
    const key = cache.get(x) || Math.random().toString(36).slice(2);

     

       
26
       
 
       
    cache.set(x, key);

     

       
27
       
-
       
    return `{"__key":"${key}"}`;

     

       
28
       
 
       
  }

     

       
29
       
 
       


     

       
30
       
 
       
  seen.add(x);

     

···

       
10
       
 
       
    return stringify(x.toJSON());

     

       
11
       
 
       
  } else if (Array.isArray(x)) {

     

       
12
       
 
       
    let out = '[';

     

       
13
       
+
       
    for (const value of x) {

     

       
14
       
+
       
      if (out.length > 1) out += ',';

     

       
15
       
+
       
      out += stringify(value) || 'null';

     

       
0
       
 
       

     

       
16
       
 
       
    }

     

       
0
       
 
       

     

       
17
       
 
       
    out += ']';

     

       
18
       
 
       
    return out;

     

       
19
       
 
       
  }

     
···

       
22
       
 
       
  if (!keys.length && x.constructor && x.constructor !== Object) {

     

       
23
       
 
       
    const key = cache.get(x) || Math.random().toString(36).slice(2);

     

       
24
       
 
       
    cache.set(x, key);

     

       
25
       
+
       
    return stringify({ __key: key });

     

       
26
       
 
       
  }

     

       
27
       
 
       


     

       
28
       
 
       
  seen.add(x);

     

···

       
1
       
-
       
const dispatchProperty = 'dispatchDebug';

     

       
2
       
 
       
const visited = 'visitedByDebugTargetTransformer';

     

       
3
       
 
       


     

       
4
       
 
       
const warningDevCheckTemplate = `

     

       
5
       
 
       
  process.env.NODE_ENV !== 'production' ? NODE : undefined

     

       
6
       
 
       
`.trim();

     

       
7
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       
const plugin = ({ template, types: t }) => {

     

       
9
       
 
       
  const wrapWithDevCheck = template.expression(

     

       
10
       
 
       
    warningDevCheckTemplate,

     

       
11
       
 
       
    { placeholderPattern: /^NODE$/ }

     

       
12
       
 
       
  );

     

       
13
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
14
       
 
       
  let name = 'unknownExchange';

     

       
15
       
 
       


     

       
16
       
 
       
  return {

     
···

       
22
       
 
       
        }

     

       
23
       
 
       
      },

     

       
24
       
 
       
      CallExpression(path, meta) {

     

       
25
       
-
       
        if (

     

       
26
       
-
       
          !path.node[visited] &&

     

       
27
       
-
       
          path.node.callee &&

     

       
28
       
-
       
          path.node.callee.name === dispatchProperty

     

       
29
       
-
       
        ) {

     

       
30
       
 
       
          path.node[visited] = true;

     

       
31
       
 
       
          if (t.isObjectExpression(path.node.arguments[0]) && !meta.filename.endsWith('compose.ts')) {

     

       
32
       
 
       
            path.node.arguments[0].properties.push(

     
···

       
38
       
 
       
          }

     

       
39
       
 
       


     

       
40
       
 
       
          path.replaceWith(wrapWithDevCheck({ NODE: path.node }));

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
41
       
 
       
        }

     

       
42
       
 
       
      }

     

       
43
       
 
       
    }

     

···

       
0
       
 
       

     

       
1
       
 
       
const visited = 'visitedByDebugTargetTransformer';

     

       
2
       
 
       


     

       
3
       
 
       
const warningDevCheckTemplate = `

     

       
4
       
 
       
  process.env.NODE_ENV !== 'production' ? NODE : undefined

     

       
5
       
 
       
`.trim();

     

       
6
       
 
       


     

       
7
       
+
       
const noopTransformTemplate = `

     

       
8
       
+
       
  process.env.NODE_ENV !== 'production' ? NODE : FALLBACK

     

       
9
       
+
       
`.trim();

     

       
10
       
+
       


     

       
11
       
 
       
const plugin = ({ template, types: t }) => {

     

       
12
       
 
       
  const wrapWithDevCheck = template.expression(

     

       
13
       
 
       
    warningDevCheckTemplate,

     

       
14
       
 
       
    { placeholderPattern: /^NODE$/ }

     

       
15
       
 
       
  );

     

       
16
       
 
       


     

       
17
       
+
       
  const wrapWithNoopTransform = template.expression(

     

       
18
       
+
       
    noopTransformTemplate,

     

       
19
       
+
       
    { placeholderPattern: /^(NODE|FALLBACK)$/ }

     

       
20
       
+
       
  );

     

       
21
       
+
       


     

       
22
       
 
       
  let name = 'unknownExchange';

     

       
23
       
 
       


     

       
24
       
 
       
  return {

     
···

       
30
       
 
       
        }

     

       
31
       
 
       
      },

     

       
32
       
 
       
      CallExpression(path, meta) {

     

       
33
       
+
       
        if (path.node[visited] || !path.node.callee) return;

     

       
34
       
+
       


     

       
35
       
+
       
        if (path.node.callee.name === 'dispatchDebug') {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
36
       
 
       
          path.node[visited] = true;

     

       
37
       
 
       
          if (t.isObjectExpression(path.node.arguments[0]) && !meta.filename.endsWith('compose.ts')) {

     

       
38
       
 
       
            path.node.arguments[0].properties.push(

     
···

       
44
       
 
       
          }

     

       
45
       
 
       


     

       
46
       
 
       
          path.replaceWith(wrapWithDevCheck({ NODE: path.node }));

     

       
47
       
+
       
        } else if (path.node.callee.name === 'addMetadata') {

     

       
48
       
+
       
          path.node[visited] = true;

     

       
49
       
+
       
          path.replaceWith(wrapWithNoopTransform({

     

       
50
       
+
       
            NODE: path.node,

     

       
51
       
+
       
            FALLBACK: path.node.arguments[0],

     

       
52
       
+
       
          }));

     

       
53
       
 
       
        }

     

       
54
       
 
       
      }

     

       
55
       
 
       
    }